New MangaSearchQuery implementation proposal
palaks-1
1 year ago
parent
8c966c3e23
commit
c0ea9cadd7
@ -0,0 +1,130 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.model.search
|
||||||
|
|
||||||
|
import org.koitharu.kotatsu.parsers.model.SortOrder
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a search query for filtering and sorting manga search results.
|
||||||
|
* This class is immutable and must be constructed using the [Builder].
|
||||||
|
*
|
||||||
|
* @property criteria The set of search criteria applied to the query.
|
||||||
|
* @property order The sorting order for the results (optional).
|
||||||
|
* @property offset The offset number for paginated search results (optional).
|
||||||
|
*/
|
||||||
|
public class MangaSearchQuery private constructor(
|
||||||
|
@JvmField public val criteria: Set<QueryCriteria<*>> = emptySet(),
|
||||||
|
@JvmField public val order: SortOrder? = null,
|
||||||
|
@JvmField public val offset: Int? = null,
|
||||||
|
) {
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean {
|
||||||
|
if (this === other) return true
|
||||||
|
if (other !is MangaSearchQuery) return false
|
||||||
|
|
||||||
|
return criteria == other.criteria &&
|
||||||
|
order == other.order &&
|
||||||
|
offset == other.offset
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
var result = criteria.hashCode()
|
||||||
|
result = 31 * result + (order?.hashCode() ?: 0)
|
||||||
|
result = 31 * result + (offset ?: 0)
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
public companion object {
|
||||||
|
public fun builder(): Builder = Builder()
|
||||||
|
}
|
||||||
|
|
||||||
|
public class Builder {
|
||||||
|
private var criteria: MutableSet<QueryCriteria<*>> = mutableSetOf()
|
||||||
|
private var order: SortOrder? = null
|
||||||
|
private var offset: Int? = null
|
||||||
|
|
||||||
|
public fun copy(searchQuery: MangaSearchQuery): Builder = apply {
|
||||||
|
this.criteria = searchQuery.criteria as MutableSet<QueryCriteria<*>>
|
||||||
|
this.order = searchQuery.order
|
||||||
|
this.offset = searchQuery.offset
|
||||||
|
}
|
||||||
|
|
||||||
|
@Throws(IllegalArgumentException::class)
|
||||||
|
public fun criterion(criterion: QueryCriteria<*>): Builder = apply {
|
||||||
|
validateCriterion(criterion)
|
||||||
|
this.criteria.add(criterion)
|
||||||
|
}
|
||||||
|
|
||||||
|
public fun order(order: SortOrder?): Builder = apply { this.order = order }
|
||||||
|
|
||||||
|
public fun offset(offset: Int?): Builder = apply { this.offset = offset }
|
||||||
|
|
||||||
|
@Throws(IllegalArgumentException::class)
|
||||||
|
public fun build(): MangaSearchQuery {
|
||||||
|
return MangaSearchQuery(deduplicateCriteria(criteria), order, offset)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validates the provided [QueryCriteria] to ensure type correctness.
|
||||||
|
*
|
||||||
|
* @param criterion The search criterion to validate.
|
||||||
|
* @throws IllegalArgumentException If the criterion type does not match the expected type.
|
||||||
|
*/
|
||||||
|
private fun validateCriterion(criterion: QueryCriteria<*>) {
|
||||||
|
try {
|
||||||
|
val expectedType = criterion.field.type
|
||||||
|
val actualType: Class<*>? = when (criterion) {
|
||||||
|
is QueryCriteria.Include<*> -> criterion.values.first().javaClass
|
||||||
|
is QueryCriteria.Exclude<*> -> criterion.values.first().javaClass
|
||||||
|
is QueryCriteria.Match<*> -> criterion.value.javaClass
|
||||||
|
is QueryCriteria.Range<*> -> {
|
||||||
|
if (criterion.from.javaClass != criterion.to.javaClass) {
|
||||||
|
throw IllegalArgumentException(
|
||||||
|
"Mismatched types for field '${criterion.field}'. 'from' and 'to' should have same types"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
criterion.from.javaClass
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val isCompatibleIntType = (expectedType == Int::class.java && actualType == Integer::class.java) ||
|
||||||
|
(expectedType == Integer::class.java && actualType == Int::class.java)
|
||||||
|
|
||||||
|
if (actualType != null && !expectedType.isAssignableFrom(actualType) && !isCompatibleIntType) {
|
||||||
|
throw IllegalArgumentException(
|
||||||
|
"Invalid type for ${criterion.field}. Expected: ${expectedType.simpleName}, but got: ${actualType.simpleName}"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
} catch (e: NoSuchElementException) {
|
||||||
|
throw IllegalArgumentException(
|
||||||
|
"QueryCriteria values should not be empty"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun deduplicateCriteria(criteria: Set<QueryCriteria<*>>): Set<QueryCriteria<*>> {
|
||||||
|
val uniqueCriteria = mutableMapOf<Pair<SearchableField, Class<out QueryCriteria<*>>>, QueryCriteria<*>>()
|
||||||
|
|
||||||
|
for (criterion in criteria) {
|
||||||
|
val key = criterion.field to criterion::class.java
|
||||||
|
val existing = uniqueCriteria[key]
|
||||||
|
|
||||||
|
when {
|
||||||
|
existing == null -> uniqueCriteria[key] = criterion
|
||||||
|
|
||||||
|
existing is QueryCriteria.Include<*> && criterion is QueryCriteria.Include<*> -> {
|
||||||
|
uniqueCriteria[key] = QueryCriteria.Include(criterion.field,existing.values union criterion.values)
|
||||||
|
}
|
||||||
|
|
||||||
|
existing is QueryCriteria.Exclude<*> && criterion is QueryCriteria.Exclude<*> -> {
|
||||||
|
uniqueCriteria[key] = QueryCriteria.Exclude(criterion.field,existing.values union criterion.values)
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> throw IllegalArgumentException(
|
||||||
|
"Match and Range have only one criterion per type, but found duplicates for: ${criterion.field} in ${criterion::class.simpleName}"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return uniqueCriteria.values.toSet()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,105 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.model.search
|
||||||
|
|
||||||
|
import org.koitharu.kotatsu.parsers.InternalParsersApi
|
||||||
|
import org.koitharu.kotatsu.parsers.model.MangaListFilterCapabilities
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.QueryCriteria.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.SearchableField.*
|
||||||
|
|
||||||
|
public data class MangaSearchQueryCapabilities(
|
||||||
|
val capabilities: Set<SearchCapability> = emptySet(),
|
||||||
|
) {
|
||||||
|
public companion object {
|
||||||
|
@InternalParsersApi
|
||||||
|
public fun from(filterCapabilities: MangaListFilterCapabilities): MangaSearchQueryCapabilities {
|
||||||
|
return MangaSearchQueryCapabilities(
|
||||||
|
capabilities = setOfNotNull(
|
||||||
|
filterCapabilities.isMultipleTagsSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = TAG, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
)
|
||||||
|
},
|
||||||
|
filterCapabilities.isTagsExclusionSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = TAG, criteriaTypes = setOf(Exclude::class), multiValue = true, otherCriteria = true
|
||||||
|
)
|
||||||
|
},
|
||||||
|
filterCapabilities.isSearchSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = TITLE_NAME, criteriaTypes = setOf(Match::class), multiValue = false, otherCriteria = false
|
||||||
|
)
|
||||||
|
},
|
||||||
|
filterCapabilities.isSearchWithFiltersSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = TITLE_NAME, criteriaTypes = setOf(Match::class), multiValue = false, otherCriteria = true
|
||||||
|
)
|
||||||
|
},
|
||||||
|
filterCapabilities.isYearSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = PUBLICATION_YEAR, criteriaTypes = setOf(Match::class), multiValue = false, otherCriteria = true
|
||||||
|
)
|
||||||
|
},
|
||||||
|
filterCapabilities.isYearRangeSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = PUBLICATION_YEAR, criteriaTypes = setOf(Range::class), multiValue = false, otherCriteria = true
|
||||||
|
)
|
||||||
|
},
|
||||||
|
filterCapabilities.isOriginalLocaleSupported.takeIf { it }?.let {
|
||||||
|
SearchCapability(
|
||||||
|
field = ORIGINAL_LANGUAGE, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
)
|
||||||
|
},
|
||||||
|
SearchCapability(
|
||||||
|
field = LANGUAGE, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
),
|
||||||
|
SearchCapability(
|
||||||
|
field = STATE, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
),
|
||||||
|
SearchCapability(
|
||||||
|
field = CONTENT_TYPE, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
),
|
||||||
|
SearchCapability(
|
||||||
|
field = CONTENT_RATING, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
),
|
||||||
|
SearchCapability(
|
||||||
|
field = DEMOGRAPHIC, criteriaTypes = setOf(Include::class), multiValue = true, otherCriteria = true
|
||||||
|
),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@InternalParsersApi
|
||||||
|
public fun validate(query: MangaSearchQuery) {
|
||||||
|
val strictFields = capabilities.filter { !it.otherCriteria }.map { it.field }.toSet()
|
||||||
|
val usedStrictFields = query.criteria.map { it.field }.toSet().intersect(strictFields)
|
||||||
|
|
||||||
|
if (usedStrictFields.isNotEmpty() && query.criteria.size > 1) {
|
||||||
|
throw IllegalArgumentException(
|
||||||
|
"Query contains multiple criteria, but at least one field (${usedStrictFields.joinToString()}) does not support multiple criteria."
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
for (criterion in query.criteria) {
|
||||||
|
val capability = capabilities.find { it.field == criterion.field }
|
||||||
|
?: throw IllegalArgumentException("Unsupported search field: ${criterion.field}")
|
||||||
|
|
||||||
|
if (criterion::class !in capability.criteriaTypes) {
|
||||||
|
throw IllegalArgumentException(
|
||||||
|
"Unsupported search criterion: ${criterion::class.simpleName} for field ${criterion.field}"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ensure single value per criterion if supportMultiValue is false
|
||||||
|
if (!capability.multiValue) {
|
||||||
|
when (criterion) {
|
||||||
|
is Include<*> -> if (criterion.values.size > 1)
|
||||||
|
throw IllegalArgumentException("Multiple values are not allowed for field ${criterion.field}")
|
||||||
|
is Exclude<*> -> if (criterion.values.size > 1)
|
||||||
|
throw IllegalArgumentException("Multiple values are not allowed for field ${criterion.field}")
|
||||||
|
is Range<*> -> {} // Range is always valid (from, to)
|
||||||
|
is Match<*> -> {} // Match always has a single value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,63 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.model.search
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a generic search criterion used for filtering manga search results.
|
||||||
|
* Each criterion applies a specific condition to a [SearchableField] and operates on values of type [T].
|
||||||
|
*
|
||||||
|
* @param T The type of value associated with the search criterion.
|
||||||
|
* @property field The field to which this search criterion applies.
|
||||||
|
*/
|
||||||
|
public sealed class QueryCriteria<T>(
|
||||||
|
@JvmField public val field: SearchableField
|
||||||
|
) {
|
||||||
|
public class Include<T : Any>(field: SearchableField, @JvmField public val values: Set<T>) : QueryCriteria<T>(field) {
|
||||||
|
override fun equals(other: Any?): Boolean {
|
||||||
|
if (this === other) return true
|
||||||
|
if (other !is Include<*>) return false
|
||||||
|
return field == other.field && values == other.values
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
return 31 * field.hashCode() + values.hashCode()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public class Exclude<T : Any>(field: SearchableField, @JvmField public val values: Set<T>) : QueryCriteria<T>(field) {
|
||||||
|
override fun equals(other: Any?): Boolean {
|
||||||
|
if (this === other) return true
|
||||||
|
if (other !is Exclude<*>) return false
|
||||||
|
return field == other.field && values == other.values
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
return 31 * field.hashCode() + values.hashCode()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public class Range<T : Comparable<T>>(field: SearchableField, @JvmField public val from: T, @JvmField public val to: T) : QueryCriteria<T>(field) {
|
||||||
|
override fun equals(other: Any?): Boolean {
|
||||||
|
if (this === other) return true
|
||||||
|
if (other !is Range<*>) return false
|
||||||
|
return field == other.field && from == other.from && to == other.to
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
var result = field.hashCode()
|
||||||
|
result = 31 * result + from.hashCode()
|
||||||
|
result = 31 * result + to.hashCode()
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public class Match<T : Any>(field: SearchableField, @JvmField public val value: T) : QueryCriteria<T>(field) {
|
||||||
|
override fun equals(other: Any?): Boolean {
|
||||||
|
if (this === other) return true
|
||||||
|
if (other !is Match<*>) return false
|
||||||
|
return field == other.field && value == other.value
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
return 31 * field.hashCode() + value.hashCode()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,10 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.model.search
|
||||||
|
|
||||||
|
import kotlin.reflect.KClass
|
||||||
|
|
||||||
|
public data class SearchCapability (
|
||||||
|
@JvmField public val field: SearchableField,
|
||||||
|
@JvmField public val criteriaTypes: Set<KClass<out QueryCriteria<*>>>,
|
||||||
|
@JvmField public val multiValue: Boolean,
|
||||||
|
@JvmField public val otherCriteria: Boolean,
|
||||||
|
)
|
||||||
@ -0,0 +1,23 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.model.search
|
||||||
|
|
||||||
|
import org.koitharu.kotatsu.parsers.model.*
|
||||||
|
import java.util.Locale
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents the various fields that can be used for searching manga.
|
||||||
|
* Each field is associated with a specific data type that defines its expected values.
|
||||||
|
*
|
||||||
|
* @property type The Java class representing the expected type of values for this field.
|
||||||
|
*/
|
||||||
|
public enum class SearchableField(public val type: Class<*>) {
|
||||||
|
TITLE_NAME(String::class.java),
|
||||||
|
TAG(MangaTag::class.java),
|
||||||
|
AUTHOR(MangaTag::class.java),
|
||||||
|
LANGUAGE(Locale::class.java),
|
||||||
|
ORIGINAL_LANGUAGE(Locale::class.java),
|
||||||
|
STATE(MangaState::class.java),
|
||||||
|
CONTENT_TYPE(ContentType::class.java),
|
||||||
|
CONTENT_RATING(ContentRating::class.java),
|
||||||
|
DEMOGRAPHIC(Demographic::class.java),
|
||||||
|
PUBLICATION_YEAR(Int::class.java);
|
||||||
|
}
|
||||||
@ -0,0 +1,154 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.util
|
||||||
|
|
||||||
|
import org.koitharu.kotatsu.parsers.InternalParsersApi
|
||||||
|
import org.koitharu.kotatsu.parsers.model.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.MangaSearchQuery
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.QueryCriteria
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.SearchableField.*
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a [MangaListFilter] into a [MangaSearchQuery].
|
||||||
|
*
|
||||||
|
* This function iterates through the filter attributes in [MangaListFilter] and creates corresponding
|
||||||
|
* search criteria in a [MangaSearchQuery.Builder].
|
||||||
|
*
|
||||||
|
* @param filter The [MangaListFilter] to convert.
|
||||||
|
* @return A [MangaSearchQuery] constructed based on the given [filter].
|
||||||
|
*/
|
||||||
|
@InternalParsersApi
|
||||||
|
public fun convertToMangaSearchQuery(offset: Int, sortOrder: SortOrder, filter: MangaListFilter): MangaSearchQuery {
|
||||||
|
return MangaSearchQuery.Builder().apply {
|
||||||
|
offset(offset)
|
||||||
|
order(sortOrder)
|
||||||
|
if (filter.tags.isNotEmpty()) criterion(QueryCriteria.Include(TAG, filter.tags))
|
||||||
|
if (filter.tagsExclude.isNotEmpty()) criterion(QueryCriteria.Exclude(TAG, filter.tagsExclude))
|
||||||
|
if (filter.states.isNotEmpty()) criterion(QueryCriteria.Include(STATE, filter.states))
|
||||||
|
if (filter.types.isNotEmpty()) criterion(QueryCriteria.Include(CONTENT_TYPE, filter.types))
|
||||||
|
if (filter.contentRating.isNotEmpty()) criterion(QueryCriteria.Include(CONTENT_RATING, filter.contentRating))
|
||||||
|
if (filter.demographics.isNotEmpty()) criterion(QueryCriteria.Include(DEMOGRAPHIC, filter.demographics))
|
||||||
|
if (validateYear(filter.yearFrom) || validateYear(filter.yearTo)) {
|
||||||
|
criterion(QueryCriteria.Range(PUBLICATION_YEAR, filter.yearFrom, filter.yearTo))
|
||||||
|
}
|
||||||
|
if (validateYear(filter.year)) {
|
||||||
|
criterion(QueryCriteria.Match(PUBLICATION_YEAR, filter.year))
|
||||||
|
}
|
||||||
|
filter.locale?.takeIf { it != null }?.let {
|
||||||
|
criterion(QueryCriteria.Include(LANGUAGE, setOf(it)))
|
||||||
|
}
|
||||||
|
filter.originalLocale?.takeIf { it != null }?.let {
|
||||||
|
criterion(QueryCriteria.Include(ORIGINAL_LANGUAGE, setOf(it)))
|
||||||
|
}
|
||||||
|
filter.query?.takeIf { it.isNotBlank() }?.let {
|
||||||
|
criterion(QueryCriteria.Match(TITLE_NAME, it))
|
||||||
|
}
|
||||||
|
}.build()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a {@link MangaSearchQuery} into a {@link MangaListFilter}.
|
||||||
|
* <p>
|
||||||
|
* This method iterates through the search criteria defined in the provided {@code searchQuery}
|
||||||
|
* and applies them to a {@link MangaListFilter.Builder}. The criteria are processed based on
|
||||||
|
* their types, such as inclusion, exclusion, equality checks, range filtering, and pattern matching.
|
||||||
|
* </p>
|
||||||
|
* <p>
|
||||||
|
* Supported criteria:
|
||||||
|
* <ul>
|
||||||
|
* <li>{@link QueryCriteria.Include} - Adds tags, states, content types, content ratings, demographics, and languages.</li>
|
||||||
|
* <li>{@link QueryCriteria.Exclude} - Excludes tags.</li>
|
||||||
|
* <li>{@link QueryCriteria.Equals} - Sets specific values like publication year.</li>
|
||||||
|
* <li>{@link QueryCriteria.Between} - Sets a range of values like publication year range.</li>
|
||||||
|
* <li>{@link QueryCriteria.Match} - Adds a search pattern for the title name.</li>
|
||||||
|
* </ul>
|
||||||
|
* </p>
|
||||||
|
* <p>
|
||||||
|
* If an unsupported field is encountered, an {@link UnsupportedOperationException} is thrown.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param searchQuery The {@link MangaSearchQuery} to convert.
|
||||||
|
* @return A {@link MangaListFilter} constructed based on the given {@code searchQuery}.
|
||||||
|
* @throws UnsupportedOperationException If the search criteria contain unsupported fields.
|
||||||
|
*/
|
||||||
|
@InternalParsersApi
|
||||||
|
public fun convertToMangaListFilter(searchQuery: MangaSearchQuery): MangaListFilter {
|
||||||
|
return MangaListFilter.Builder().apply {
|
||||||
|
for (criterion in searchQuery.criteria) {
|
||||||
|
when (criterion) {
|
||||||
|
is QueryCriteria.Include<*> -> handleInclude(this, criterion)
|
||||||
|
is QueryCriteria.Exclude<*> -> handleExclude(this, criterion)
|
||||||
|
is QueryCriteria.Range<*> -> handleBetween(this, criterion)
|
||||||
|
is QueryCriteria.Match<*> -> handleMatch(this, criterion)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}.build()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun handleInclude(builder: MangaListFilter.Builder, criterion: QueryCriteria.Include<*>) {
|
||||||
|
val type = criterion.field.type
|
||||||
|
|
||||||
|
when (criterion.field) {
|
||||||
|
TAG -> builder.addTags(filterValues(criterion, type))
|
||||||
|
STATE -> builder.addStates(filterValues(criterion, type))
|
||||||
|
CONTENT_TYPE -> builder.addTypes(filterValues(criterion, type))
|
||||||
|
CONTENT_RATING -> builder.addContentRatings(filterValues(criterion, type))
|
||||||
|
DEMOGRAPHIC -> builder.addDemographics(filterValues(criterion, type))
|
||||||
|
LANGUAGE -> builder.locale(getFirstValue(criterion, type))
|
||||||
|
ORIGINAL_LANGUAGE -> builder.originalLocale(getFirstValue(criterion, type))
|
||||||
|
else -> throw UnsupportedOperationException("Unsupported field for Include criterion: ${criterion.field}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun handleExclude(builder: MangaListFilter.Builder, criterion: QueryCriteria.Exclude<*>) {
|
||||||
|
val type = criterion.field.type
|
||||||
|
|
||||||
|
when (criterion.field) {
|
||||||
|
TAG -> builder.excludeTags(filterValues(criterion, type))
|
||||||
|
else -> throw UnsupportedOperationException("Unsupported field for Exclude criterion: ${criterion.field}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun handleBetween(builder: MangaListFilter.Builder, criterion: QueryCriteria.Range<*>) {
|
||||||
|
val type = criterion.field.type
|
||||||
|
|
||||||
|
when (criterion.field) {
|
||||||
|
PUBLICATION_YEAR -> {
|
||||||
|
builder.yearFrom(getValue(criterion.from, type, YEAR_UNKNOWN))
|
||||||
|
builder.yearTo(getValue(criterion.to, type, YEAR_UNKNOWN))
|
||||||
|
}
|
||||||
|
else -> throw UnsupportedOperationException("Unsupported field for Between criterion: ${criterion.field}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun handleMatch(builder: MangaListFilter.Builder, criterion: QueryCriteria.Match<*>) {
|
||||||
|
val type = criterion.field.type
|
||||||
|
|
||||||
|
when (criterion.field) {
|
||||||
|
TITLE_NAME -> builder.query(getValue(criterion.value, type, ""))
|
||||||
|
PUBLICATION_YEAR -> builder.year(getValue(criterion.value, type, YEAR_UNKNOWN))
|
||||||
|
else -> throw UnsupportedOperationException("Unsupported field for Match criterion: ${criterion.field}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Suppress("UNCHECKED_CAST")
|
||||||
|
private fun <T> filterValues(criterion: QueryCriteria.Include<*>, type: Class<*>): List<T> {
|
||||||
|
return criterion.values.filter { type.isInstance(it) } as List<T>
|
||||||
|
}
|
||||||
|
|
||||||
|
@Suppress("UNCHECKED_CAST")
|
||||||
|
private fun <T> filterValues(criterion: QueryCriteria.Exclude<*>, type: Class<*>): List<T> {
|
||||||
|
return criterion.values.filter { type.isInstance(it) } as List<T>
|
||||||
|
}
|
||||||
|
|
||||||
|
@Suppress("UNCHECKED_CAST")
|
||||||
|
private fun <T> getFirstValue(criterion: QueryCriteria.Include<*>, type: Class<*>): T? {
|
||||||
|
return criterion.values.firstOrNull { type.isInstance(it) } as? T
|
||||||
|
}
|
||||||
|
|
||||||
|
@Suppress("UNCHECKED_CAST")
|
||||||
|
private fun <T> getValue(value: Any?, type: Class<*>, default: T): T {
|
||||||
|
val isCompatibleIntType = (type == Int::class.java && Integer::class.isInstance(value))
|
||||||
|
|
||||||
|
return if (type.isInstance(value) || isCompatibleIntType) value as T else default
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun validateYear(year: Int) = year != null && year != YEAR_UNKNOWN
|
||||||
@ -0,0 +1,72 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.model.search
|
||||||
|
|
||||||
|
import org.junit.jupiter.api.Assertions.assertDoesNotThrow
|
||||||
|
import org.junit.jupiter.api.Assertions.assertThrows
|
||||||
|
import org.junit.jupiter.api.Test
|
||||||
|
import org.koitharu.kotatsu.parsers.model.MangaParserSource
|
||||||
|
import org.koitharu.kotatsu.parsers.model.MangaState
|
||||||
|
import org.koitharu.kotatsu.parsers.model.MangaTag
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.QueryCriteria.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.SearchableField.*
|
||||||
|
import java.util.Locale
|
||||||
|
|
||||||
|
class MangaSearchQueryCapabilitiesTest {
|
||||||
|
|
||||||
|
private val capabilities = MangaSearchQueryCapabilities(
|
||||||
|
capabilities = setOf(
|
||||||
|
SearchCapability(TITLE_NAME, setOf(Match::class), multiValue = false, otherCriteria = false),
|
||||||
|
SearchCapability(TAG, setOf(Include::class, Exclude::class), multiValue = true, otherCriteria = true),
|
||||||
|
SearchCapability(PUBLICATION_YEAR, setOf(Range::class), multiValue = false, otherCriteria = true),
|
||||||
|
SearchCapability(STATE, setOf(Include::class), multiValue = false, otherCriteria = true),
|
||||||
|
)
|
||||||
|
)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun validateValidSingleCriterionQuery() {
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Match(TITLE_NAME, "title"))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
assertDoesNotThrow { capabilities.validate(query) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun validateUnsupportedFieldThrowsException() {
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Include(ORIGINAL_LANGUAGE, setOf(Locale.ENGLISH)))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
assertThrows(IllegalArgumentException::class.java) { capabilities.validate(query) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun validateUnsupportedMultiValueThrowsException() {
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Include(STATE, setOf(MangaState.ONGOING, MangaState.FINISHED)))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
assertThrows(IllegalArgumentException::class.java) { capabilities.validate(query) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun validateMultipleCriteriaWithOtherCriteriaAllowed() {
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Include(TAG, setOf(buildTag("tag1"), buildTag("tag2"))))
|
||||||
|
.criterion(Exclude(TAG, setOf(buildTag("tag3"))))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
assertDoesNotThrow { capabilities.validate(query) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun validateMultipleCriteriaWithStrictCapabilityThrowsException() {
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Match(TITLE_NAME, "title"))
|
||||||
|
.criterion(Range(PUBLICATION_YEAR, 1990, 2000))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
assertThrows(IllegalArgumentException::class.java) { capabilities.validate(query) }
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildTag(name: String) = MangaTag(title = name, key = "${name}Key", source = MangaParserSource.DUMMY)
|
||||||
|
}
|
||||||
@ -0,0 +1,77 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.util
|
||||||
|
|
||||||
|
import org.junit.jupiter.api.Assertions.assertEquals
|
||||||
|
import org.junit.jupiter.api.Test
|
||||||
|
import org.koitharu.kotatsu.parsers.model.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.ContentType.MANGA
|
||||||
|
import org.koitharu.kotatsu.parsers.model.ContentType.MANHUA
|
||||||
|
import org.koitharu.kotatsu.parsers.model.Demographic.SEINEN
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.MangaSearchQuery
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.QueryCriteria.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.SearchableField.*
|
||||||
|
import java.util.*
|
||||||
|
|
||||||
|
class ListFilterToSearchQueryConverterTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun convertToMangaSearchQueryTest() {
|
||||||
|
val tags = setOf(buildMangaTag("tag1"), buildMangaTag("tag2"))
|
||||||
|
val excludedTags = setOf(buildMangaTag("exclude_tag"))
|
||||||
|
val states = setOf(MangaState.ONGOING)
|
||||||
|
val contentRatings = setOf(ContentRating.SAFE)
|
||||||
|
val contentTypes = setOf(MANGA, MANHUA)
|
||||||
|
val demographics = setOf(SEINEN)
|
||||||
|
|
||||||
|
val filter = MangaListFilter(
|
||||||
|
query = "title_name",
|
||||||
|
tags = tags,
|
||||||
|
tagsExclude = excludedTags,
|
||||||
|
locale = Locale.ENGLISH,
|
||||||
|
originalLocale = Locale.JAPANESE,
|
||||||
|
states = states,
|
||||||
|
contentRating = contentRatings,
|
||||||
|
types = contentTypes,
|
||||||
|
demographics = demographics,
|
||||||
|
year = 2020,
|
||||||
|
yearFrom = 1997,
|
||||||
|
yearTo = 2024
|
||||||
|
)
|
||||||
|
|
||||||
|
val searchQuery = convertToMangaSearchQuery(0, SortOrder.NEWEST, filter)
|
||||||
|
|
||||||
|
val expectedQuery = MangaSearchQuery.builder()
|
||||||
|
.offset(0)
|
||||||
|
.order(SortOrder.NEWEST)
|
||||||
|
.criterion(Match(TITLE_NAME, "title_name"))
|
||||||
|
.criterion(Include(TAG, tags))
|
||||||
|
.criterion(Exclude(TAG, excludedTags))
|
||||||
|
.criterion(Include(LANGUAGE, setOf(Locale.ENGLISH)))
|
||||||
|
.criterion(Include(ORIGINAL_LANGUAGE, setOf(Locale.JAPANESE)))
|
||||||
|
.criterion(Include(STATE, states))
|
||||||
|
.criterion(Include(CONTENT_RATING, contentRatings))
|
||||||
|
.criterion(Include(CONTENT_TYPE, contentTypes))
|
||||||
|
.criterion(Include(DEMOGRAPHIC, demographics))
|
||||||
|
.criterion(Range(PUBLICATION_YEAR, 1997, 2024))
|
||||||
|
.criterion(Match(PUBLICATION_YEAR, 2020))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
assertEquals(expectedQuery, searchQuery)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun convertToMangaSearchQueryWithEmptyFieldsTest() {
|
||||||
|
val filter = MangaListFilter()
|
||||||
|
|
||||||
|
val searchQuery = convertToMangaSearchQuery(0, SortOrder.NEWEST, filter)
|
||||||
|
|
||||||
|
assertEquals(MangaSearchQuery.builder().offset(0).order(SortOrder.NEWEST).build(), searchQuery)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildMangaTag(name: String): MangaTag {
|
||||||
|
return MangaTag(
|
||||||
|
key = "${name}Key",
|
||||||
|
title = name,
|
||||||
|
source = MangaParserSource.DUMMY
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,90 @@
|
|||||||
|
package org.koitharu.kotatsu.parsers.util
|
||||||
|
|
||||||
|
import org.junit.jupiter.api.Assertions.assertEquals
|
||||||
|
import org.junit.jupiter.api.Test
|
||||||
|
import org.junit.jupiter.api.assertThrows
|
||||||
|
import org.koitharu.kotatsu.parsers.model.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.ContentType.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.Demographic.SEINEN
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.QueryCriteria.*
|
||||||
|
import org.koitharu.kotatsu.parsers.model.search.SearchableField.*
|
||||||
|
import java.util.*
|
||||||
|
|
||||||
|
class ConvertToMangaListFilterTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun convertToMangaListFilterTest() {
|
||||||
|
val tags = setOf(buildMangaTag("tag1"), buildMangaTag("tag2"))
|
||||||
|
val excludedTags = setOf(buildMangaTag("exclude_tag"))
|
||||||
|
val states = setOf(MangaState.ONGOING)
|
||||||
|
val contentRatings = setOf(ContentRating.SAFE)
|
||||||
|
val contentTypes = setOf(MANGA, MANHUA)
|
||||||
|
val demographics = setOf(SEINEN)
|
||||||
|
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Match(TITLE_NAME, "title_name"))
|
||||||
|
.criterion(Include(TAG, tags))
|
||||||
|
.criterion(Exclude(TAG, excludedTags))
|
||||||
|
.criterion(Include(LANGUAGE, setOf(Locale.ENGLISH)))
|
||||||
|
.criterion(Include(ORIGINAL_LANGUAGE, setOf(Locale.JAPANESE)))
|
||||||
|
.criterion(Include(STATE, states))
|
||||||
|
.criterion(Include(CONTENT_RATING, contentRatings))
|
||||||
|
.criterion(Include(CONTENT_TYPE, contentTypes))
|
||||||
|
.criterion(Include(DEMOGRAPHIC, demographics))
|
||||||
|
.criterion(Range(PUBLICATION_YEAR, 1997, 2024))
|
||||||
|
.criterion(Match(PUBLICATION_YEAR, 2020))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
val listFilter = convertToMangaListFilter(query)
|
||||||
|
|
||||||
|
assertEquals(listFilter.query, "title_name")
|
||||||
|
assertEquals(listFilter.tags, tags)
|
||||||
|
assertEquals(listFilter.tagsExclude, excludedTags)
|
||||||
|
assertEquals(listFilter.locale, Locale.ENGLISH)
|
||||||
|
assertEquals(listFilter.originalLocale, Locale.JAPANESE)
|
||||||
|
assertEquals(listFilter.states, states)
|
||||||
|
assertEquals(listFilter.contentRating, contentRatings)
|
||||||
|
assertEquals(listFilter.types, contentTypes)
|
||||||
|
assertEquals(listFilter.demographics, demographics)
|
||||||
|
assertEquals(listFilter.year, 2020)
|
||||||
|
assertEquals(listFilter.yearFrom, 1997)
|
||||||
|
assertEquals(listFilter.yearTo, 2024)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun convertToMangaListFilterWithMultipleTagsIncludeTest() {
|
||||||
|
val tags1 = setOf(buildMangaTag("tag1"), buildMangaTag("tag2"))
|
||||||
|
val tags2 = setOf(buildMangaTag("tag3"), buildMangaTag("tag4"))
|
||||||
|
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Include(TAG, tags1))
|
||||||
|
.criterion(Include(TAG, tags2))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
val listFilter = convertToMangaListFilter(query)
|
||||||
|
|
||||||
|
assertEquals(listFilter.tags, tags1 union tags2)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun convertToMangaListFilterWithUnsupportedFieldTest() {
|
||||||
|
val query = MangaSearchQuery.builder()
|
||||||
|
.criterion(Include(AUTHOR, setOf(buildMangaTag("author"))))
|
||||||
|
.build()
|
||||||
|
|
||||||
|
val exception = assertThrows<UnsupportedOperationException> {
|
||||||
|
convertToMangaListFilter(query)
|
||||||
|
}
|
||||||
|
|
||||||
|
assert(exception.message!!.contains("Unsupported field for Include criterion: AUTHOR"))
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildMangaTag(name: String): MangaTag {
|
||||||
|
return MangaTag(
|
||||||
|
key = "${name}Key",
|
||||||
|
title = name,
|
||||||
|
source = MangaParserSource.DUMMY,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue