SharpRSS/SharpRss/Services/DatabaseService.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Dapper;
using Microsoft.Data.Sqlite;
using Serilog;
using SharpRss.Models;

namespace SharpRss.Services
{
    internal class DatabaseService : IDisposable
    {
        internal DatabaseService()
        {
            _sqlConn = new SqliteConnection(_connectionString);
            InitializeDb();
        }
        private readonly SqliteConnection _sqlConn;
        private readonly string _connectionString = $"Data Source={Path.Combine(Environment.CurrentDirectory, "sharp_rss.sqlite")};";
        private readonly string _groupTable = "group_data";
        private readonly string _feedTable = "feed_data";
        private readonly string _feedItemTable = "feed_item_data";

        // Groups
        public async Task<HashSet<GroupModel>> GetGroupsAsync(string? groupId = null)
        {
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand(groupId != null ? $"SELECT * FROM {_groupTable} WHERE id=@gId;" : $"SELECT * FROM {_groupTable}", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("gId", groupId)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            HashSet<GroupModel> groups = new HashSet<GroupModel>();
            await using SqliteCommand cmdFeedCount = new SqliteCommand($"SELECT COUNT(*) FROM {_feedTable} WHERE group_id=@groupId", _sqlConn);
            while (reader.Read())
            {
                cmdFeedCount.Parameters.Clear();
                cmdFeedCount.Parameters.Add(new SqliteParameter("groupId", reader["id"].ToString()));
                using SqliteDataReader countReader = await cmdFeedCount.ExecuteReaderAsync();
                int count = countReader.Read() ? countReader.GetInt32(0) : 0;

				groups.Add(new GroupModel()
                {
                    Name = reader["name"].ToString(),
                    FeedCount = count,
                    HexColor = reader["hex_color"].ToString(),
                    Icon = reader["icon"].ToString(),
                    Id = reader["id"].ToString()
                });
            }
            _sqlConn.Close();
            return groups;
        }

        /// <summary>
        /// Creates a group if not exists then update the group.
        /// </summary>
        /// <param name="groupModel"></param>
        /// <returns></returns>
        public async Task<bool> SetGroupAsync(GroupModel groupModel)
        {
            bool result = false;
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand($"INSERT OR REPLACE INTO {_groupTable} (id, hex_color, icon, name) VALUES (IFNULL((SELECT id FROM {_groupTable} WHERE name=@name), @id), @hexColor, @icon, @name)", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("id", groupModel.Id),
                    new SqliteParameter("hexColor", groupModel.HexColor),
                    new SqliteParameter("icon", groupModel.Icon),
                    new SqliteParameter("name", groupModel.Name)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            _sqlConn.Close();
            return result;
        }

        public async Task<bool> RemoveGroupAsync(GroupModel groupModel)
        {
            bool result = false;
            _sqlConn.Open();
			// Remove the group and remove the feeds that were part of the group.
            await using SqliteCommand cmd = new SqliteCommand($"DELETE FROM {_groupTable} WHERE id=@id; UPDATE {_feedTable} SET group_id=NULL WHERE group_id=@id", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("id", groupModel.Id)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            _sqlConn.Close();
            return result;
        }
        // Feeds
        public async Task<HashSet<FeedModel>> GetFeedsAsync(string? groupId = null)
        {
            HashSet<FeedModel> feeds = new HashSet<FeedModel>();
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand(groupId != null ? $"SELECT * FROM {_feedTable} WHERE group_id=@groupId" : $"SELECT * FROM {_feedTable}", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("groupId", groupId == null ? string.Empty : groupId)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            while (reader.Read())
            {
                feeds.Add(ReaderToFeedModel(reader));
            }
            _sqlConn.Close();
            return feeds;
        }

        private FeedModel ReaderToFeedModel(SqliteDataReader reader)
        {
            return new FeedModel(reader["url"].ToString())
            {
                Id = reader["id"].ToString(),
                Title = reader["title"].ToString(),
                GroupId = reader["group_id"].ToString(),
                FeedType = reader["feed_type"].ToString(),
                Description = reader["description"].ToString(),
                Language = reader["language"].ToString(),
                Copyright = reader["copyright"].ToString(),
                DateAdded = DateTimeOffset.FromUnixTimeMilliseconds(long.TryParse(reader["date_added"].ToString(), out long parsedVal) ? parsedVal : 0),
                LastUpdated = DateTimeOffset.FromUnixTimeMilliseconds(long.TryParse(reader["last_updated"].ToString(), out long lastUpdated) ? lastUpdated : 0),
                ImageUrl = reader["image_url"].ToString(),
                OriginalDocument = reader["original_document"].ToString()
            };
        }

        public async Task<FeedModel?> SetFeedAsync(FeedModel feedModel)
        {
            FeedModel? resultModel = null;
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand($"INSERT OR REPLACE INTO {_feedTable} (id, url, title, group_id, feed_type, description, language, copyright, date_added, last_updated, image_url, original_document) VALUES (IFNULL((SELECT id FROM {_feedTable} WHERE url=@url), @id), @url, @title, @groupId, @feedType, @description, @language, @copyright, IFNULL((SELECT date_added FROM {_feedTable} WHERE id=@id), @dateAdded), @lastUpdated, @imageUrl, @originalDoc); SELECT * FROM {_feedTable} WHERE url=@url", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("id", feedModel.Id ?? string.Empty),
                    new SqliteParameter("url", feedModel.Url ?? string.Empty),
                    new SqliteParameter("title", feedModel.Title ?? string.Empty),
                    new SqliteParameter("groupId", feedModel.GroupId ?? string.Empty),
                    new SqliteParameter("feedType", feedModel.FeedType ?? string.Empty),
                    new SqliteParameter("description", feedModel.Description ?? string.Empty),
                    new SqliteParameter("language", feedModel.Language ?? string.Empty),
                    new SqliteParameter("copyright", feedModel.Copyright ?? string.Empty),
                    new SqliteParameter("dateAdded", feedModel.DateAdded?.ToUnixTimeMilliseconds()),
                    new SqliteParameter("lastUpdated", feedModel.LastUpdated?.ToUnixTimeMilliseconds()),
                    new SqliteParameter("imageUrl", feedModel.ImageUrl ?? string.Empty),
                    new SqliteParameter("originalDoc", feedModel.OriginalDocument ?? string.Empty)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            if (reader.Read())
                resultModel = ReaderToFeedModel(reader);
            _sqlConn.Close();
            return resultModel;
        }
        public async Task<bool> RemoveFeedAsync(FeedModel feedModel)
        {
            bool result = false;
            _sqlConn.Open(); // After removing the feed unset the feed id from the feed items
            await using SqliteCommand cmd = new SqliteCommand($"DELETE FROM {_feedTable} WHERE id=@id; UPDATE {_feedItemTable} SET feed_id=NULL WHERE feed_id=@id", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("id", feedModel.Id)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            _sqlConn.Close();
            return result;
        }
        // Feed items
        public async Task<HashSet<FeedItemModel>> GetFeedItemsAsync(string[]? feedIds = null)
        {
            List<string>? formattedIds = feedIds?.Select(s => $"'{s}'").ToList();
            HashSet<FeedItemModel> feedItems = new HashSet<FeedItemModel>();
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand(
                formattedIds != null
                    ? $"SELECT * FROM {_feedItemTable} WHERE feed_id IN ({string.Join(", ", formattedIds)})"
                    : $"SELECT * FROM {_feedItemTable}", _sqlConn);

            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            while (reader.Read())
            {
                feedItems.Add(new FeedItemModel()
                {
                    Id = reader["id"].ToString(),
                    FeedId = reader["feed_id"].ToString(),
                    Read = int.TryParse(reader["read"].ToString(), out int parsedValue) && parsedValue != 0,
                    Title = reader["title"].ToString(),
                    Description = reader["description"].ToString(),
                    Link = reader["link"].ToString(),
                    LastUpdated = DateTimeOffset.FromUnixTimeMilliseconds(long.Parse(reader["last_updated"].ToString())),
                    PublishingDate = DateTimeOffset.FromUnixTimeMilliseconds(long.Parse(reader["publishing_date"].ToString())),
                    Author = reader["author"].ToString(),
                    Categories = reader["categories"].ToString().Split(','),
                    Content = reader["content"].ToString()
				});
            }
            _sqlConn.Close();
            return feedItems;
        }
        public async Task<int> SetFeedItemsAsync(HashSet<FeedItemModel> items)
        {
            int result = 0;
            _sqlConn.Open();
            await using SqliteTransaction transaction = _sqlConn.BeginTransaction();
            await using SqliteCommand cmd = new SqliteCommand($"INSERT OR REPLACE INTO {_feedItemTable} (id, feed_id, read, title, description, link, last_updated, publishing_date, author, categories, content)" +
                                                              $"VALUES (IFNULL((SELECT id FROM {_feedItemTable} WHERE link=@link), @id), @feedId, @read, @title, @description, @link, @lastUpdated, @publishingDate, @author, @categories, @content)", _sqlConn);
            foreach (FeedItemModel item in items)
            {
                cmd.Parameters.Clear();
                cmd.Parameters.Add(new SqliteParameter("id", item.Id ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("feedId", item.FeedId ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("read", item.Read ? 1 : 0));
                cmd.Parameters.Add(new SqliteParameter("type", item.Type ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("title", item.Title ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("description", item.Description ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("link", item.Link ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("lastUpdated", item.LastUpdated?.ToUnixTimeMilliseconds()));
                cmd.Parameters.Add(new SqliteParameter("publishingDate", item.PublishingDate?.ToUnixTimeMilliseconds() ?? 0));
                cmd.Parameters.Add(new SqliteParameter("author", item.Author ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("categories", item.Categories != null ? string.Join(',', item.Categories) : string.Empty));
                cmd.Parameters.Add(new SqliteParameter("content", item.Content ?? string.Empty));
                if (_sqlConn.State != ConnectionState.Open)
                    _sqlConn.Open();
                int affected = await cmd.ExecuteNonQueryAsync();
                if (affected == 0)
					Log.Verbose("Could not set feed item: {FeedLink}", item.Link);
                else
				    result += affected;
			}
            transaction.Commit();
            _sqlConn.Close();
            return result; // Return the amount affected rows.
        }
        public async Task<bool> RemoveFeedItemAsync(FeedItemModel itemModel)
        {
            bool result = false;
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand($"DELETE FROM {_feedItemTable} WHERE id=@id", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter("id", itemModel.Id)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            _sqlConn.Close();
            return result;
        }
        public async Task<GroupModel?> GetGroupFromFeedItemAsync(FeedItemModel feedItem)
        {
            GroupModel? result = null;
            _sqlConn.Open();
            await using SqliteCommand cmd = new SqliteCommand($"SELECT * FROM {_groupTable} WHERE id=(SELECT group_id FROM {_feedTable} WHERE id=@fId)", _sqlConn)
            {
                Parameters =
                {
                    new SqliteParameter ("fId", feedItem.Id)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            HashSet<GroupModel>? groups = null;
            if (reader.Read())
                groups = await GetGroupsAsync(reader["group_id"].ToString());
            if (groups != null && groups.Any())
                result = groups.FirstOrDefault();
            _sqlConn.Close();
            return result;
        }

        private async void InitializeDb()
        {
            Log.Verbose("Checking database...");
            HashSet<string> failed = new HashSet<string>();
            _sqlConn.Open();
            Log.Verbose("Checking table: {Table}", _groupTable);
            var queryResponse = await _sqlConn.QueryAsync($"CREATE TABLE IF NOT EXISTS {_groupTable} (name STRING NOT NULL, hex_color STRING NOT NULL, icon STRING, id STRING PRIMARY KEY)");
            if (queryResponse.Any()) failed.Add("category_data");
			
			Log.Verbose("Checking table: {Table}", _feedTable);
			queryResponse = await _sqlConn.QueryAsync($"CREATE TABLE IF NOT EXISTS {_feedTable} (id STRING PRIMARY KEY, url STRING NOT NULL, title STRING, group_id STRING, feed_type STRING, description STRING, language STRING, copyright STRING, date_added INT, last_updated INT, image_url STRING, original_document STRING)");
            if (queryResponse.Any()) failed.Add("feed_data");

            Log.Verbose("Checking table: {Table}", _feedItemTable);
            queryResponse = await _sqlConn.QueryAsync($"CREATE TABLE IF NOT EXISTS {_feedItemTable} (id STRING PRIMARY KEY, feed_id STRING, read INT, title STRING, description STRING, link STRING, last_updated INT, publishing_date INT, author STRING, categories STRING, content STRING)");
            if (queryResponse.Any()) failed.Add("feed_item_data");
            
            _sqlConn.Close();
            if (failed.Any())
            {
                var joined = string.Join(',', failed);
                Log.Error("Failed to initialize table(s): {TableNames}", joined);
            }
            else
                Log.Verbose("Checking database done!");
        }

        public void Dispose()
        {
            _sqlConn.Dispose();
        }
    }
}