98 lines
3.8 KiB
Kotlin
98 lines
3.8 KiB
Kotlin
package be.simplenotes.domain.usecases
|
|
|
|
import arrow.core.Either
|
|
import arrow.core.extensions.fx
|
|
import be.simplenotes.domain.model.Note
|
|
import be.simplenotes.domain.model.PersistedNote
|
|
import be.simplenotes.domain.model.PersistedNoteMetadata
|
|
import be.simplenotes.domain.security.HtmlSanitizer
|
|
import be.simplenotes.domain.usecases.markdown.MarkdownConverter
|
|
import be.simplenotes.domain.usecases.markdown.MarkdownParsingError
|
|
import be.simplenotes.domain.usecases.repositories.NoteRepository
|
|
import be.simplenotes.domain.usecases.repositories.UserRepository
|
|
import be.simplenotes.domain.usecases.search.NoteSearcher
|
|
import be.simplenotes.domain.usecases.search.SearchTerms
|
|
import java.util.*
|
|
|
|
class NoteService(
|
|
private val markdownConverter: MarkdownConverter,
|
|
private val noteRepository: NoteRepository,
|
|
private val userRepository: UserRepository,
|
|
private val searcher: NoteSearcher,
|
|
) {
|
|
|
|
fun create(userId: Int, markdownText: String) = Either.fx<MarkdownParsingError, PersistedNote> {
|
|
val persistedNote = !markdownConverter.renderDocument(markdownText)
|
|
.map { it.copy(html = HtmlSanitizer.sanitize(it.html)) }
|
|
.map { Note(it.metadata, markdown = markdownText, html = it.html) }
|
|
.map { noteRepository.create(userId, it) }
|
|
|
|
searcher.indexNote(userId, persistedNote)
|
|
persistedNote
|
|
}
|
|
|
|
fun update(userId: Int, uuid: UUID, markdownText: String) = Either.fx<MarkdownParsingError, PersistedNote?> {
|
|
val persistedNote = !markdownConverter.renderDocument(markdownText)
|
|
.map { it.copy(html = HtmlSanitizer.sanitize(it.html)) }
|
|
.map { Note(it.metadata, markdown = markdownText, html = it.html) }
|
|
.map { noteRepository.update(userId, uuid, it) }
|
|
|
|
persistedNote?.let { searcher.updateIndex(userId, it) }
|
|
persistedNote
|
|
}
|
|
|
|
fun paginatedNotes(
|
|
userId: Int,
|
|
page: Int,
|
|
itemsPerPage: Int = 20,
|
|
tag: String? = null,
|
|
deleted: Boolean = false,
|
|
): PaginatedNotes {
|
|
val count = noteRepository.count(userId, tag, deleted)
|
|
val offset = (page - 1) * itemsPerPage
|
|
val numberOfPages = (count / itemsPerPage) + 1
|
|
val notes = if (count == 0) emptyList() else noteRepository.findAll(userId, itemsPerPage, offset, tag, deleted)
|
|
return PaginatedNotes(numberOfPages, notes)
|
|
}
|
|
|
|
fun find(userId: Int, uuid: UUID) = noteRepository.find(userId, uuid)
|
|
|
|
fun trash(userId: Int, uuid: UUID): Boolean {
|
|
val res = noteRepository.delete(userId, uuid, permanent = false)
|
|
if (res) searcher.deleteIndex(userId, uuid)
|
|
return res
|
|
}
|
|
|
|
fun restore(userId: Int, uuid: UUID): Boolean {
|
|
val res = noteRepository.restore(userId, uuid)
|
|
if (res) find(userId, uuid)?.let { note -> searcher.indexNote(userId, note) }
|
|
return res
|
|
}
|
|
|
|
fun delete(userId: Int, uuid: UUID): Boolean {
|
|
val res = noteRepository.delete(userId, uuid, permanent = true)
|
|
if (res) searcher.deleteIndex(userId, uuid)
|
|
return res
|
|
}
|
|
|
|
fun countDeleted(userId: Int) = noteRepository.count(userId, deleted = true)
|
|
|
|
fun indexAll() {
|
|
val userIds = userRepository.findAll()
|
|
userIds.forEach { id ->
|
|
val notes = noteRepository.findAllDetails(id)
|
|
searcher.indexNotes(id, notes)
|
|
}
|
|
}
|
|
|
|
fun search(userId: Int, searchTerms: SearchTerms) = searcher.search(userId, searchTerms)
|
|
|
|
fun dropAllIndexes() = searcher.dropAll()
|
|
|
|
fun makePublic(userId: Int, uuid: UUID) = noteRepository.makePublic(userId, uuid)
|
|
fun makePrivate(userId: Int, uuid: UUID) = noteRepository.makePrivate(userId, uuid)
|
|
fun findPublic(uuid: UUID) = noteRepository.findPublic(uuid)
|
|
}
|
|
|
|
data class PaginatedNotes(val pages: Int, val notes: List<PersistedNoteMetadata>)
|