prepare for multiple apps

2026-04-06 12:23:11 +02:00
parent bd1600e8dc
commit 5afc323f04
904 changed files with 29 additions and 29 deletions
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2024-2026 Fabian Freund.
+ *
+ * This file is part of WebLibre
+ * (see https://weblibre.eu).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+import 'package:drift/drift.dart';
+import 'package:weblibre/features/web_feed/data/database/daos/article.drift.dart';
+import 'package:weblibre/features/web_feed/data/database/database.dart';
+import 'package:weblibre/features/web_feed/data/database/definitions.drift.dart';
+import 'package:weblibre/features/web_feed/data/models/feed_article.dart';
+import 'package:weblibre/features/web_feed/data/models/feed_article_query_result.dart';
+
+@DriftAccessor()
+class ArticleDao extends DatabaseAccessor<FeedDatabase> with $ArticleDaoMixin {
+  ArticleDao(super.attachedDatabase);
+
+  Selectable<FeedArticle> getFeedArticles(Uri? url) {
+    final select = db.articleView.select();
+
+    if (url != null) {
+      select.where((article) => article.feedId.equalsValue(url));
+    }
+
+    return select..orderBy([
+      (row) => OrderingTerm(
+        expression: coalesce([row.updated, row.created]),
+        mode: OrderingMode.desc,
+      ),
+    ]);
+  }
+
+  Selectable<FeedArticle> getUnprocessedArticles() {
+    return db.articleView.select()..where(
+      (article) =>
+          (article.contentHtml.isNotNull() &
+              (article.contentMarkdown.isNull() |
+                  article.contentPlain.isNull())) |
+          (article.summaryHtml.isNotNull() &
+              (article.summaryMarkdown.isNull() |
+                  article.summaryPlain.isNull())),
+    );
+  }
+
+  SingleOrNullSelectable<FeedArticle> getArticleById(String articleId) {
+    return db.articleView.select()..where((row) => row.id.equals(articleId));
+  }
+
+  Future<void> updateArticleContent(List<FeedArticle> articles) {
+    return db.transaction(() async {
+      await Future.wait(
+        articles.map((newArticle) {
+          final statement = db.article.update()
+            ..where((article) => article.id.equals(newArticle.id));
+
+          return statement.write(
+            ArticleCompanion(
+              summaryHtml: Value(newArticle.summaryHtml),
+              summaryMarkdown: Value(newArticle.summaryMarkdown),
+              summaryPlain: Value(newArticle.summaryPlain),
+              contentHtml: Value(newArticle.contentHtml),
+              contentMarkdown: Value(newArticle.contentMarkdown),
+              contentPlain: Value(newArticle.contentPlain),
+            ),
+          );
+        }),
+      );
+    });
+  }
+
+  Future<void> upsertArticles(List<FeedArticle> articles) {
+    return db.transaction(() async {
+      await Future.wait(
+        articles
+            .map(
+              (article) => db.article.insertOne(
+                article,
+                onConflict: DoUpdate(
+                  (old) {
+                    return ArticleCompanion(
+                      authors: Value(article.authors),
+                      contentHtml: Value(article.contentHtml),
+                      contentMarkdown: Value(article.contentMarkdown),
+                      contentPlain: Value(article.contentPlain),
+                      links: Value(article.links),
+                      summaryHtml: Value(article.summaryHtml),
+                      summaryMarkdown: Value(article.summaryMarkdown),
+                      summaryPlain: Value(article.summaryPlain),
+                      tags: Value(article.tags),
+                      title: Value(article.title),
+                      updated: Value(article.updated),
+                    );
+                  },
+                  where: (old) =>
+                      old.updated.isNotNull() &
+                      old.updated.isSmallerThanValue(
+                        article.updated ?? DateTime(0),
+                      ),
+                ),
+              ),
+            )
+            .toList(),
+      );
+    });
+  }
+
+  Future<int> updateArticleRead(String articleId, DateTime? read) {
+    final statement = db.article.update()
+      ..where((article) => article.id.equals(articleId));
+
+    return statement.write(ArticleCompanion(lastRead: Value(read)));
+  }
+
+  Selectable<(String, int)> getUnreadArticleCount() {
+    final count = countAll();
+
+    final countByFeed = db.article.selectOnly()
+      ..addColumns([db.article.feedId, count])
+      ..where(
+        db.article.lastRead.isNull() |
+            (db.article.updated.isNotNull() &
+                db.article.lastRead.isSmallerThan(db.article.lastRead)),
+      )
+      ..groupBy([db.article.feedId]);
+
+    return countByFeed.map(
+      (result) => (result.read(db.article.feedId)!, result.read(count)!),
+    );
+  }
+
+  Selectable<FeedArticleQueryResult> queryArticles({
+    required String matchPrefix,
+    required String matchSuffix,
+    required String ellipsis,
+    required int snippetLength,
+    required String searchString,
+    required Uri? feedId,
+    int limit = 25,
+  }) {
+    final ftsQuery = db.buildFtsQuery(searchString);
+
+    if (ftsQuery.isNotEmpty) {
+      return db.definitionsDrift.queryArticlesFullContent(
+        feedId: feedId?.toString(),
+        query: ftsQuery,
+        snippetLength: snippetLength,
+        beforeMatch: matchPrefix,
+        afterMatch: matchSuffix,
+        ellipsis: ellipsis,
+        limit: limit,
+      );
+    } else {
+      return db.definitionsDrift.queryArticlesBasic(
+        feedId: feedId?.toString(),
+        query: db.buildLikeQuery(searchString),
+        limit: limit,
+      );
+    }
+  }
+}
@@ -0,0 +1,13 @@
+// dart format width=80
+// ignore_for_file: type=lint
+import 'package:drift/drift.dart' as i0;
+import 'package:weblibre/features/web_feed/data/database/database.dart' as i1;
+
+mixin $ArticleDaoMixin on i0.DatabaseAccessor<i1.FeedDatabase> {
+  ArticleDaoManager get managers => ArticleDaoManager(this);
+}
+
+class ArticleDaoManager {
+  final $ArticleDaoMixin _db;
+  ArticleDaoManager(this._db);
+}
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024-2026 Fabian Freund.
+ *
+ * This file is part of WebLibre
+ * (see https://weblibre.eu).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+import 'package:drift/drift.dart';
+import 'package:weblibre/features/web_feed/data/database/daos/feed.drift.dart';
+import 'package:weblibre/features/web_feed/data/database/database.dart';
+import 'package:weblibre/features/web_feed/data/database/definitions.drift.dart';
+
+@DriftAccessor()
+class FeedDao extends DatabaseAccessor<FeedDatabase> with $FeedDaoMixin {
+  FeedDao(super.attachedDatabase);
+
+  Selectable<FeedData> getFeeds() {
+    return db.feed.select();
+  }
+
+  SingleOrNullSelectable<FeedData> getFeed(Uri feedId) {
+    return db.feed.select()..where((feed) => feed.url.equalsValue(feedId));
+  }
+
+  Future<int> updateFeedFetched(Uri feedId, DateTime fetched) {
+    final statement = db.feed.update()
+      ..where((feed) => feed.url.equalsValue(feedId));
+
+    return statement.write(FeedCompanion(lastFetched: Value(fetched)));
+  }
+
+  Future<int> deleteFeed(Uri feedId) {
+    return db.feed.deleteWhere((feed) => feed.url.equals(feedId.toString()));
+  }
+
+  Future<int> upsertFeed(FeedData feedData) {
+    return db.feed.insertOne(
+      feedData,
+      onConflict: DoUpdate((old) {
+        return FeedCompanion(
+          authors: Value(feedData.authors),
+          title: Value(feedData.title),
+          description: Value(feedData.description),
+          tags: Value(feedData.tags),
+        );
+      }),
+    );
+  }
+}
@@ -0,0 +1,13 @@
+// dart format width=80
+// ignore_for_file: type=lint
+import 'package:drift/drift.dart' as i0;
+import 'package:weblibre/features/web_feed/data/database/database.dart' as i1;
+
+mixin $FeedDaoMixin on i0.DatabaseAccessor<i1.FeedDatabase> {
+  FeedDaoManager get managers => FeedDaoManager(this);
+}
+
+class FeedDaoManager {
+  final $FeedDaoMixin _db;
+  FeedDaoManager(this._db);
+}