mirror of
https://github.com/hmaxnl/SharpRSS.git
synced 2024-09-20 01:54:20 +02:00
325 lines
16 KiB
C#
325 lines
16 KiB
C#
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();
|
|
}
|
|
}
|
|
} |