525 lines
15 KiB
Dart
525 lines
15 KiB
Dart
import 'dart:convert';
|
|
import 'dart:core';
|
|
import 'dart:math';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:journaler/notes.dart';
|
|
import 'package:journaler/meilisearch_config.dart';
|
|
|
|
const noteIndex = 'notes';
|
|
const scratchIndex = 'scratch';
|
|
const settingsIndex = 'settings';
|
|
final alphanum = RegExp(r'[a-zA-Z0-9]', caseSensitive: false);
|
|
|
|
Future<Map<String, String>> _getHeaders() async {
|
|
final apiKey = await getMeilisearchApiKey();
|
|
return {
|
|
'Authorization': 'Bearer $apiKey',
|
|
'Content-Type': 'application/json',
|
|
};
|
|
}
|
|
|
|
Future<String> _getEndpoint() async {
|
|
return await getMeilisearchEndpoint();
|
|
}
|
|
|
|
class MeilisearchQuery {
|
|
String q;
|
|
String? filter;
|
|
int? limit;
|
|
int? offset;
|
|
bool? showRankingScore;
|
|
double? rankingScoreThreshold;
|
|
String? highlightPreTag;
|
|
String? highlightPostTag;
|
|
List<String>? attributesToHighlight;
|
|
List<String>? sort;
|
|
|
|
MeilisearchQuery({
|
|
required this.q,
|
|
this.filter,
|
|
this.sort,
|
|
this.limit,
|
|
this.offset,
|
|
this.showRankingScore,
|
|
this.rankingScoreThreshold,
|
|
this.highlightPreTag,
|
|
this.highlightPostTag,
|
|
this.attributesToHighlight,
|
|
});
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final Map<String, dynamic> json = {'q': q};
|
|
if (filter != null) json['filter'] = filter;
|
|
if (sort != null) json['sort'] = sort;
|
|
if (limit != null) json['limit'] = limit;
|
|
if (offset != null) json['offset'] = offset;
|
|
if (showRankingScore != null) json['showRankingScore'] = showRankingScore;
|
|
if (rankingScoreThreshold != null) {
|
|
json['rankingScoreThreshold'] = rankingScoreThreshold;
|
|
}
|
|
if (highlightPreTag != null) json['highlightPreTag'] = highlightPreTag;
|
|
if (highlightPostTag != null) json['highlightPostTag'] = highlightPostTag;
|
|
if (attributesToHighlight != null) {
|
|
json['attributesToHighlight'] = attributesToHighlight;
|
|
}
|
|
return json;
|
|
}
|
|
}
|
|
|
|
class MeilisearchResponse {
|
|
final List<dynamic> hits;
|
|
final String query;
|
|
final int processingTimeMs;
|
|
final int limit;
|
|
final int offset;
|
|
final int estimatedTotalHits;
|
|
|
|
MeilisearchResponse({
|
|
required this.hits,
|
|
required this.query,
|
|
required this.processingTimeMs,
|
|
required this.limit,
|
|
required this.offset,
|
|
required this.estimatedTotalHits,
|
|
});
|
|
|
|
static MeilisearchResponse fromJson(Map<String, dynamic> json) {
|
|
return MeilisearchResponse(
|
|
hits: json['hits'],
|
|
query: json['query'],
|
|
processingTimeMs: json['processingTimeMs'],
|
|
limit: json['limit'],
|
|
offset: json['offset'],
|
|
estimatedTotalHits: json['estimatedTotalHits'],
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> init() async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
|
|
if (!await indexExists(noteIndex)) {
|
|
await http.post(
|
|
Uri.parse('$endpoint/indexes'),
|
|
headers: headers,
|
|
body: jsonEncode({'uid': noteIndex, 'primaryKey': 'id'}),
|
|
);
|
|
}
|
|
await http.put(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/settings/sortable-attributes'),
|
|
headers: headers,
|
|
body: jsonEncode(['date']),
|
|
);
|
|
await http.put(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/settings/filterable-attributes'),
|
|
headers: headers,
|
|
body: jsonEncode(['date', 'topLetter', 'topLetterFrequency']),
|
|
);
|
|
|
|
if (!await indexExists(scratchIndex)) {
|
|
await http.post(
|
|
Uri.parse('$endpoint/indexes'),
|
|
headers: headers,
|
|
body: jsonEncode({'uid': scratchIndex, 'primaryKey': 'id'}),
|
|
);
|
|
}
|
|
await http.put(
|
|
Uri.parse('$endpoint/indexes/$scratchIndex/settings/sortable-attributes'),
|
|
headers: headers,
|
|
body: jsonEncode(['date']),
|
|
);
|
|
await http.put(
|
|
Uri.parse('$endpoint/indexes/$scratchIndex/settings/filterable-attributes'),
|
|
headers: headers,
|
|
body: jsonEncode(['date']),
|
|
);
|
|
|
|
if (!await indexExists(settingsIndex)) {
|
|
await http.post(
|
|
Uri.parse('$endpoint/indexes'),
|
|
headers: headers,
|
|
body: jsonEncode({'uid': settingsIndex, 'primaryKey': 'key'}),
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<bool> indexExists(String index) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final response = await http.get(
|
|
Uri.parse('$endpoint/indexes/$index'),
|
|
headers: headers,
|
|
);
|
|
return response.statusCode == 200;
|
|
}
|
|
|
|
// Settings Management
|
|
Future<String?> getSetting(String key) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(q: '', filter: 'key = $key');
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$settingsIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception('Failed to get settings');
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
if (responseJson.hits.isEmpty) {
|
|
return null;
|
|
}
|
|
return responseJson.hits.first['value'] as String?;
|
|
}
|
|
|
|
Future<void> setSetting(String key, String value) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final document = {'key': key, 'value': value};
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$settingsIndex/documents'),
|
|
headers: headers,
|
|
body: jsonEncode(document),
|
|
);
|
|
if (response.statusCode != 202) {
|
|
throw Exception('Failed to set settings');
|
|
}
|
|
}
|
|
|
|
// Maybe we could factor a lot of this out into a separate function
|
|
// But we don't care for now...
|
|
Future<List<Note>> searchNotes(String query) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(
|
|
q: query,
|
|
limit: 10,
|
|
attributesToHighlight: ['content'],
|
|
showRankingScore: true,
|
|
highlightPreTag: '<highlight>',
|
|
highlightPostTag: '</highlight>',
|
|
);
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception('Failed to search notes');
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
return responseJson.hits
|
|
.map(
|
|
(hit) => Note(
|
|
id: hit['id'] as String,
|
|
epochTime: hit['date'] as int,
|
|
content: hit['content'] as String,
|
|
snippet: hit['_formatted']['content'] as String,
|
|
),
|
|
)
|
|
.toList();
|
|
}
|
|
|
|
Future<Note?> getPreviousTo(int epochTime) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(
|
|
q: '',
|
|
filter: 'date < $epochTime',
|
|
sort: ['date:desc'],
|
|
limit: 1,
|
|
);
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception(
|
|
'Failed to get previous note, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
if (responseJson.hits.isEmpty) {
|
|
return null;
|
|
}
|
|
return Note(
|
|
id: responseJson.hits.first['id'] as String,
|
|
epochTime: responseJson.hits.first['date'] as int,
|
|
content: responseJson.hits.first['content'] as String,
|
|
);
|
|
}
|
|
|
|
Future<Note?> getNextTo(int epochTime) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(
|
|
q: '',
|
|
filter: 'date > $epochTime',
|
|
sort: ['date:asc'],
|
|
limit: 1,
|
|
);
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception(
|
|
'Failed to get next note, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
if (responseJson.hits.isEmpty) {
|
|
return null;
|
|
}
|
|
return Note(
|
|
id: responseJson.hits.first['id'] as String,
|
|
epochTime: responseJson.hits.first['date'] as int,
|
|
content: responseJson.hits.first['content'] as String,
|
|
);
|
|
}
|
|
|
|
Future<Note?> getLatest() async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(
|
|
q: '',
|
|
sort: ['date:desc'],
|
|
limit: 1,
|
|
);
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception(
|
|
'Failed to get latest note, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
if (responseJson.hits.isEmpty) {
|
|
return null;
|
|
}
|
|
return Note(
|
|
id: responseJson.hits.first['id'] as String,
|
|
epochTime: responseJson.hits.first['date'] as int,
|
|
content: responseJson.hits.first['content'] as String,
|
|
);
|
|
}
|
|
|
|
String generateRandomString(int length) {
|
|
const characters =
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
|
var result = '';
|
|
for (var i = 0; i < length; i++) {
|
|
final randomIndex = Random().nextInt(characters.length);
|
|
result += characters[randomIndex];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Future<Note> createNote(String content) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final lines = content.split('\n');
|
|
final trimmedLines = <String>[];
|
|
for (final line in lines) {
|
|
final trimmedContent = line.trim().replaceAll(RegExp(r'\s{2,}'), ' ');
|
|
if (trimmedContent.isEmpty) {
|
|
continue;
|
|
}
|
|
trimmedLines.add(trimmedContent);
|
|
}
|
|
final trimmedContent = trimmedLines.join('\n');
|
|
|
|
final letterFrequency = <String, int>{};
|
|
for (final char in trimmedContent.split('')) {
|
|
if (alphanum.hasMatch(char)) {
|
|
letterFrequency[char] = (letterFrequency[char] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
final mostFrequentLetter =
|
|
letterFrequency.entries.reduce((a, b) => a.value > b.value ? a : b).key;
|
|
final mostFrequentLetterCount =
|
|
letterFrequency[mostFrequentLetter]! / trimmedContent.length;
|
|
|
|
final document = {
|
|
'id': generateRandomString(32),
|
|
'date': DateTime.now().toUtc().millisecondsSinceEpoch,
|
|
'dateISO': DateTime.now().toUtc().toIso8601String(),
|
|
'content': content,
|
|
'topLetter': mostFrequentLetter,
|
|
'topLetterFrequency': mostFrequentLetterCount,
|
|
};
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/documents'),
|
|
headers: headers,
|
|
body: jsonEncode(document),
|
|
);
|
|
if (response.statusCode != 202) {
|
|
throw Exception('Failed to create note');
|
|
}
|
|
return Note(
|
|
id: document['id'] as String,
|
|
epochTime: document['date'] as int,
|
|
content: document['content'] as String,
|
|
);
|
|
}
|
|
|
|
Future<List<Note>> getProblematic({double threshold = 0.7}) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(
|
|
q: '',
|
|
filter: 'topLetterFrequency > $threshold',
|
|
);
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception(
|
|
'Failed to get problematic notes, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
return responseJson.hits
|
|
.map(
|
|
(hit) => Note(
|
|
id: hit['id'] as String,
|
|
epochTime: hit['date'] as int,
|
|
content: hit['content'] as String,
|
|
isProblematic: true,
|
|
problemReason:
|
|
'Character "${hit['topLetter']}" makes up ${(hit['topLetterFrequency'] * 100).toStringAsFixed(1)}% of the content',
|
|
),
|
|
)
|
|
.toList();
|
|
}
|
|
|
|
// TODO: only update if changed
|
|
// How? idk
|
|
Future<void> updateNote(Note note) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final lines = note.content.split('\n');
|
|
final trimmedLines = <String>[];
|
|
for (final line in lines) {
|
|
final trimmedContent = line.trim().replaceAll(RegExp(r'\s{2,}'), ' ');
|
|
if (trimmedContent.isEmpty) {
|
|
continue;
|
|
}
|
|
trimmedLines.add(trimmedContent);
|
|
}
|
|
final trimmedContent = trimmedLines.join('\n');
|
|
|
|
final letterFrequency = <String, int>{};
|
|
for (final char in trimmedContent.split('')) {
|
|
if (alphanum.hasMatch(char)) {
|
|
letterFrequency[char] = (letterFrequency[char] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
final mostFrequentLetter =
|
|
letterFrequency.entries.reduce((a, b) => a.value > b.value ? a : b).key;
|
|
final mostFrequentLetterRatio =
|
|
letterFrequency[mostFrequentLetter]! / trimmedContent.length;
|
|
|
|
final document = {
|
|
'id': note.id,
|
|
'content': trimmedContent,
|
|
'date': note.epochTime,
|
|
'dateISO':
|
|
DateTime.fromMillisecondsSinceEpoch(
|
|
note.epochTime,
|
|
).toUtc().toIso8601String(),
|
|
'topLetter': mostFrequentLetter,
|
|
'topLetterFrequency': mostFrequentLetterRatio,
|
|
};
|
|
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/documents'),
|
|
headers: headers,
|
|
body: jsonEncode(document),
|
|
);
|
|
if (response.statusCode != 202) {
|
|
throw Exception(
|
|
'Failed to update note, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> deleteNote(String id) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final response = await http.delete(
|
|
Uri.parse('$endpoint/indexes/$noteIndex/documents/$id'),
|
|
headers: headers,
|
|
);
|
|
if (response.statusCode != 202) {
|
|
throw Exception(
|
|
'Failed to delete note, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<Scratch?> getLatestScratch() async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final searchCondition = MeilisearchQuery(
|
|
q: '',
|
|
sort: ['date:desc'],
|
|
limit: 1,
|
|
);
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$scratchIndex/search'),
|
|
headers: headers,
|
|
body: jsonEncode(searchCondition.toJson()),
|
|
);
|
|
if (response.statusCode != 200) {
|
|
throw Exception(
|
|
'Failed to get latest scratch, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
final responseJson = MeilisearchResponse.fromJson(jsonDecode(response.body));
|
|
if (responseJson.hits.isEmpty) {
|
|
return null;
|
|
}
|
|
return Scratch(
|
|
id: responseJson.hits.first['id'] as String,
|
|
epochTime: responseJson.hits.first['date'] as int,
|
|
content: responseJson.hits.first['content'] as String,
|
|
);
|
|
}
|
|
|
|
Future<Scratch> createScratch(String content) async {
|
|
final endpoint = await _getEndpoint();
|
|
final headers = await _getHeaders();
|
|
final document = {
|
|
'id': generateRandomString(32),
|
|
'date': DateTime.now().toUtc().millisecondsSinceEpoch,
|
|
'content': content,
|
|
};
|
|
final response = await http.post(
|
|
Uri.parse('$endpoint/indexes/$scratchIndex/documents'),
|
|
headers: headers,
|
|
body: jsonEncode(document),
|
|
);
|
|
if (response.statusCode != 202) {
|
|
throw Exception(
|
|
'Failed to create scratch, backend responded with ${response.statusCode}',
|
|
);
|
|
}
|
|
return Scratch(
|
|
id: document['id'] as String,
|
|
epochTime: document['date'] as int,
|
|
content: document['content'] as String,
|
|
);
|
|
}
|