de.comhix.database.dao.Query.kt Maven / Gradle / Ivy

Go to download
package de.comhix.database.dao

import de.comhix.database.objects.QueryResult
import org.mongodb.morphia.Datastore
import org.mongodb.morphia.query.FindOptions

/**
 * @author Benjamin Beeker
 */
open class Query {
    private lateinit var query: org.mongodb.morphia.query.Query
    private val options = FindOptions()

    /**
     * only for [de.comhix.database.dao.test.MockQuery]
     */
    protected constructor() {}

    constructor(typeClass: Class, datastore: Datastore) {
        query = datastore.createQuery(typeClass)
    }

    open fun  with(field: String?, operation: Operation, value: AllowedValueType): Query {
        if (operation === Operation.EQ) {
            query.field(field).equal(value)
        }
        else if (operation === Operation.NEQ) {
            query.field(field).notEqual(value)
        }
        else if (operation === Operation.GT) {
            query.field(field).greaterThan(value)
        }
        else if (operation === Operation.GEQ) {
            query.field(field).greaterThanOrEq(value)
        }
        else if (operation === Operation.LT) {
            query.field(field).lessThan(value)
        }
        else if (operation === Operation.LEQ) {
            query.field(field).lessThanOrEq(value)
        }
        else if (operation === Operation.EXISTS) {
            if (value as Boolean) {
                query.field(field).exists()
            }
            else {
                query.field(field).doesNotExist()
            }
        }
        else if (operation === Operation.IN) {
            query.field(field).`in`(value as Iterable<*>)
        }
        else if (operation === Operation.NOT_IN) {
            query.field(field).notIn(value as Iterable<*>)
        }
        else if (operation === Operation.HAS) {
            query.field(field).hasThisOne(value)
        }
        else if (operation === Operation.HAS_ANY) {
            query.field(field).hasAnyOf(value as Iterable<*>)
        }
        else if (operation === Operation.HAS_NONE) {
            query.field(field).hasNoneOf(value as Iterable<*>)
        }
        else if (operation === Operation.HAS_ALL) {
            query.field(field).hasAllOf(value as Iterable<*>)
        }
        return this
    }

    open fun limit(limit: Int): Query {
        options.limit(limit)
        return this
    }

    open fun skip(skip: Int): Query {
        options.skip(skip)
        return this
    }

    open fun order(field: String?): Query {
        query.order(field)
        return this
    }

    open suspend fun query(): QueryResult {
        return QueryResult(query.asList(), query.count())
    }

    open suspend fun find(): Type? {
        limit(1)
        return query().let {
            if (it.isEmpty()) {
                it[0]
            }
            else {
                null
            }
        }
    }

    class Operation {
        companion object {
            val EQ: Operation = Operation()
            val NEQ: Operation = Operation()
            val GT: Operation> = Operation()
            val GEQ: Operation> = Operation()
            val LT: Operation> = Operation()
            val LEQ: Operation> = Operation()
            val EXISTS: Operation = Operation()
            val IN: Operation> = Operation()
            val NOT_IN: Operation> = Operation()
            val HAS: Operation = Operation()
            val HAS_ANY: Operation> = Operation()
            val HAS_NONE: Operation> = Operation()
            val HAS_ALL: Operation> = Operation()
        }
    }
}