QuettaCode API/com.quettacode.flow.templates.repository/TemplateRepository

TemplateRepository

@Repository

interface TemplateRepository : JpaRepository<Template, String> (source)

Functions

count

abstract fun count(): Long

abstract fun <S : Template> count(example: Example<S>): Long

delete

abstract fun delete(entity: Template)

deleteAll

abstract fun deleteAll()

abstract fun deleteAll(entities: MutableIterable<Template>)

deleteAllById

abstract fun deleteAllById(ids: MutableIterable<String>)

deleteAllByIdInBatch

abstract fun deleteAllByIdInBatch(ids: MutableIterable<String>)

deleteAllInBatch

abstract fun deleteAllInBatch()

abstract fun deleteAllInBatch(entities: MutableIterable<Template>)

deleteById

abstract fun deleteById(id: String)

deleteInBatch

open fun ~~deleteInBatch~~(entities: MutableIterable<Template>)

exists

abstract fun <S : Template> exists(example: Example<S>): Boolean

existsById

abstract fun existsById(id: String): Boolean

findAll

abstract override fun <S : Template> findAll(example: Example<S>): MutableList<S>

abstract override fun <S : Template> findAll(example: Example<S>, sort: Sort): MutableList<S>

abstract override fun findAll(): MutableList<Template>

abstract override fun findAll(sort: Sort): MutableList<Template>

abstract fun findAll(pageable: Pageable): Page<Template>

abstract fun <S : Template> findAll(example: Example<S>, pageable: Pageable): Page<S>

findAllById

abstract override fun findAllById(ids: MutableIterable<String>): MutableList<Template>

findBy

abstract fun <S : Template, R : Any> findBy(example: Example<S>, queryFunction: Function<FluentQuery.FetchableFluentQuery<S>, R>): R

findById

abstract fun findById(id: String): Optional<Template>

findByTenantId

abstract fun findByTenantId(tenantId: String): List<Template>

findByTenantIdAndNameAndLanguage

abstract fun findByTenantIdAndNameAndLanguage(tenantId: String, name: String, language: String): Optional<Template>

findByTenantIdAndNameContainingIgnoreCase

abstract fun findByTenantIdAndNameContainingIgnoreCase(tenantId: String, name: String): List<Template>

findOne

abstract fun <S : Template> findOne(example: Example<S>): Optional<S>

flush

abstract fun flush()

getById

abstract fun ~~getById~~(id: String): Template

getOne

abstract fun ~~getOne~~(id: String): Template

getReferenceById

abstract fun getReferenceById(id: String): Template

save

abstract fun <S : Template> save(entity: S): S

saveAll

abstract override fun <S : Template> saveAll(entities: MutableIterable<S>): MutableList<S>

saveAllAndFlush

abstract fun <S : Template> saveAllAndFlush(entities: MutableIterable<S>): MutableList<S>

saveAndFlush

abstract fun <S : Template> saveAndFlush(entity: S): S