All Downloads are FREE. Search and download functionalities are using the official Maven repository.

cn.vertxup.workflow.domain.tables.daos.WTodoDao Maven / Gradle / Ivy

The newest version!
/*
 * This file is generated by jOOQ.
 */
package cn.vertxup.workflow.domain.tables.daos;


import cn.vertxup.workflow.domain.tables.WTodo;
import cn.vertxup.workflow.domain.tables.records.WTodoRecord;
import io.github.jklingsporn.vertx.jooq.classic.jdbc.JDBCClassicQueryExecutor;
import io.github.jklingsporn.vertx.jooq.shared.internal.AbstractVertxDAO;
import io.vertx.core.Future;
import org.jooq.Configuration;

import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
/**
 * This class is generated by jOOQ.
 */
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public class WTodoDao extends AbstractVertxDAO>, Future, Future, Future> implements io.github.jklingsporn.vertx.jooq.classic.VertxDAO {

        /**
     * @param configuration The Configuration used for rendering and query
     * execution.
     * @param vertx the vertx instance
     */
        public WTodoDao(Configuration configuration, io.vertx.core.Vertx vertx) {
                super(WTodo.W_TODO, cn.vertxup.workflow.domain.tables.pojos.WTodo.class, new JDBCClassicQueryExecutor(configuration,cn.vertxup.workflow.domain.tables.pojos.WTodo.class,vertx));
        }

        @Override
        protected String getId(cn.vertxup.workflow.domain.tables.pojos.WTodo object) {
                return object.getKey();
        }

        /**
     * Find records that have SERIAL IN (values) asynchronously
     */
        public Future> findManyBySerial(Collection values) {
                return findManyByCondition(WTodo.W_TODO.SERIAL.in(values));
        }

        /**
     * Find records that have SERIAL IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyBySerial(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.SERIAL.in(values),limit);
        }

        /**
     * Find records that have NAME IN (values) asynchronously
     */
        public Future> findManyByName(Collection values) {
                return findManyByCondition(WTodo.W_TODO.NAME.in(values));
        }

        /**
     * Find records that have NAME IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByName(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.NAME.in(values),limit);
        }

        /**
     * Find records that have CODE IN (values) asynchronously
     */
        public Future> findManyByCode(Collection values) {
                return findManyByCondition(WTodo.W_TODO.CODE.in(values));
        }

        /**
     * Find records that have CODE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByCode(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.CODE.in(values),limit);
        }

        /**
     * Find records that have ICON IN (values) asynchronously
     */
        public Future> findManyByIcon(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ICON.in(values));
        }

        /**
     * Find records that have ICON IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByIcon(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ICON.in(values),limit);
        }

        /**
     * Find records that have STATUS IN (values) asynchronously
     */
        public Future> findManyByStatus(Collection values) {
                return findManyByCondition(WTodo.W_TODO.STATUS.in(values));
        }

        /**
     * Find records that have STATUS IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByStatus(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.STATUS.in(values),limit);
        }

        /**
     * Find records that have TODO_URL IN (values) asynchronously
     */
        public Future> findManyByTodoUrl(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TODO_URL.in(values));
        }

        /**
     * Find records that have TODO_URL IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByTodoUrl(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TODO_URL.in(values),limit);
        }

        /**
     * Find records that have TYPE IN (values) asynchronously
     */
        public Future> findManyByType(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TYPE.in(values));
        }

        /**
     * Find records that have TYPE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByType(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TYPE.in(values),limit);
        }

        /**
     * Find records that have EXPIRED_AT IN (values) asynchronously
     */
        public Future> findManyByExpiredAt(Collection values) {
                return findManyByCondition(WTodo.W_TODO.EXPIRED_AT.in(values));
        }

        /**
     * Find records that have EXPIRED_AT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByExpiredAt(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.EXPIRED_AT.in(values),limit);
        }

        /**
     * Find records that have MODEL_ID IN (values) asynchronously
     */
        public Future> findManyByModelId(Collection values) {
                return findManyByCondition(WTodo.W_TODO.MODEL_ID.in(values));
        }

        /**
     * Find records that have MODEL_ID IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByModelId(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.MODEL_ID.in(values),limit);
        }

        /**
     * Find records that have MODEL_KEY IN (values) asynchronously
     */
        public Future> findManyByModelKey(Collection values) {
                return findManyByCondition(WTodo.W_TODO.MODEL_KEY.in(values));
        }

        /**
     * Find records that have MODEL_KEY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByModelKey(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.MODEL_KEY.in(values),limit);
        }

        /**
     * Find records that have MODEL_CATEGORY IN (values)
     * asynchronously
     */
        public Future> findManyByModelCategory(Collection values) {
                return findManyByCondition(WTodo.W_TODO.MODEL_CATEGORY.in(values));
        }

        /**
     * Find records that have MODEL_CATEGORY IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByModelCategory(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.MODEL_CATEGORY.in(values),limit);
        }

        /**
     * Find records that have PARENT_ID IN (values) asynchronously
     */
        public Future> findManyByParentId(Collection values) {
                return findManyByCondition(WTodo.W_TODO.PARENT_ID.in(values));
        }

        /**
     * Find records that have PARENT_ID IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByParentId(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.PARENT_ID.in(values),limit);
        }

        /**
     * Find records that have SERIAL_FORK IN (values)
     * asynchronously
     */
        public Future> findManyBySerialFork(Collection values) {
                return findManyByCondition(WTodo.W_TODO.SERIAL_FORK.in(values));
        }

        /**
     * Find records that have SERIAL_FORK IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyBySerialFork(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.SERIAL_FORK.in(values),limit);
        }

        /**
     * Find records that have TRACE_ID IN (values) asynchronously
     */
        public Future> findManyByTraceId(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TRACE_ID.in(values));
        }

        /**
     * Find records that have TRACE_ID IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByTraceId(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TRACE_ID.in(values),limit);
        }

        /**
     * Find records that have TRACE_ORDER IN (values)
     * asynchronously
     */
        public Future> findManyByTraceOrder(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TRACE_ORDER.in(values));
        }

        /**
     * Find records that have TRACE_ORDER IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByTraceOrder(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TRACE_ORDER.in(values),limit);
        }

        /**
     * Find records that have TASK_ID IN (values) asynchronously
     */
        public Future> findManyByTaskId(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TASK_ID.in(values));
        }

        /**
     * Find records that have TASK_ID IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByTaskId(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TASK_ID.in(values),limit);
        }

        /**
     * Find records that have TASK_KEY IN (values) asynchronously
     */
        public Future> findManyByTaskKey(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TASK_KEY.in(values));
        }

        /**
     * Find records that have TASK_KEY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByTaskKey(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TASK_KEY.in(values),limit);
        }

        /**
     * Find records that have COMMENT IN (values) asynchronously
     */
        public Future> findManyByComment(Collection values) {
                return findManyByCondition(WTodo.W_TODO.COMMENT.in(values));
        }

        /**
     * Find records that have COMMENT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByComment(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.COMMENT.in(values),limit);
        }

        /**
     * Find records that have COMMENT_APPROVAL IN (values)
     * asynchronously
     */
        public Future> findManyByCommentApproval(Collection values) {
                return findManyByCondition(WTodo.W_TODO.COMMENT_APPROVAL.in(values));
        }

        /**
     * Find records that have COMMENT_APPROVAL IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByCommentApproval(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.COMMENT_APPROVAL.in(values),limit);
        }

        /**
     * Find records that have COMMENT_REJECT IN (values)
     * asynchronously
     */
        public Future> findManyByCommentReject(Collection values) {
                return findManyByCondition(WTodo.W_TODO.COMMENT_REJECT.in(values));
        }

        /**
     * Find records that have COMMENT_REJECT IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByCommentReject(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.COMMENT_REJECT.in(values),limit);
        }

        /**
     * Find records that have TO_LOCATION IN (values)
     * asynchronously
     */
        public Future> findManyByToLocation(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TO_LOCATION.in(values));
        }

        /**
     * Find records that have TO_LOCATION IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByToLocation(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TO_LOCATION.in(values),limit);
        }

        /**
     * Find records that have TO_GROUP IN (values) asynchronously
     */
        public Future> findManyByToGroup(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TO_GROUP.in(values));
        }

        /**
     * Find records that have TO_GROUP IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByToGroup(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TO_GROUP.in(values),limit);
        }

        /**
     * Find records that have TO_TEAM IN (values) asynchronously
     */
        public Future> findManyByToTeam(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TO_TEAM.in(values));
        }

        /**
     * Find records that have TO_TEAM IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByToTeam(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TO_TEAM.in(values),limit);
        }

        /**
     * Find records that have TO_ROLE IN (values) asynchronously
     */
        public Future> findManyByToRole(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TO_ROLE.in(values));
        }

        /**
     * Find records that have TO_ROLE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByToRole(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TO_ROLE.in(values),limit);
        }

        /**
     * Find records that have TO_USER IN (values) asynchronously
     */
        public Future> findManyByToUser(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TO_USER.in(values));
        }

        /**
     * Find records that have TO_USER IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByToUser(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TO_USER.in(values),limit);
        }

        /**
     * Find records that have TO_DEPT IN (values) asynchronously
     */
        public Future> findManyByToDept(Collection values) {
                return findManyByCondition(WTodo.W_TODO.TO_DEPT.in(values));
        }

        /**
     * Find records that have TO_DEPT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByToDept(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.TO_DEPT.in(values),limit);
        }

        /**
     * Find records that have ESCALATE IN (values) asynchronously
     */
        public Future> findManyByEscalate(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ESCALATE.in(values));
        }

        /**
     * Find records that have ESCALATE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByEscalate(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ESCALATE.in(values),limit);
        }

        /**
     * Find records that have ESCALATE_DATA IN (values)
     * asynchronously
     */
        public Future> findManyByEscalateData(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ESCALATE_DATA.in(values));
        }

        /**
     * Find records that have ESCALATE_DATA IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByEscalateData(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ESCALATE_DATA.in(values),limit);
        }

        /**
     * Find records that have ASSIGNED_BY IN (values)
     * asynchronously
     */
        public Future> findManyByAssignedBy(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ASSIGNED_BY.in(values));
        }

        /**
     * Find records that have ASSIGNED_BY IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByAssignedBy(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ASSIGNED_BY.in(values),limit);
        }

        /**
     * Find records that have ASSIGNED_AT IN (values)
     * asynchronously
     */
        public Future> findManyByAssignedAt(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ASSIGNED_AT.in(values));
        }

        /**
     * Find records that have ASSIGNED_AT IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByAssignedAt(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ASSIGNED_AT.in(values),limit);
        }

        /**
     * Find records that have ACCEPTED_BY IN (values)
     * asynchronously
     */
        public Future> findManyByAcceptedBy(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ACCEPTED_BY.in(values));
        }

        /**
     * Find records that have ACCEPTED_BY IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByAcceptedBy(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ACCEPTED_BY.in(values),limit);
        }

        /**
     * Find records that have ACCEPTED_GROUP IN (values)
     * asynchronously
     */
        public Future> findManyByAcceptedGroup(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ACCEPTED_GROUP.in(values));
        }

        /**
     * Find records that have ACCEPTED_GROUP IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByAcceptedGroup(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ACCEPTED_GROUP.in(values),limit);
        }

        /**
     * Find records that have ACCEPTED_AT IN (values)
     * asynchronously
     */
        public Future> findManyByAcceptedAt(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ACCEPTED_AT.in(values));
        }

        /**
     * Find records that have ACCEPTED_AT IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByAcceptedAt(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ACCEPTED_AT.in(values),limit);
        }

        /**
     * Find records that have FINISHED_BY IN (values)
     * asynchronously
     */
        public Future> findManyByFinishedBy(Collection values) {
                return findManyByCondition(WTodo.W_TODO.FINISHED_BY.in(values));
        }

        /**
     * Find records that have FINISHED_BY IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByFinishedBy(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.FINISHED_BY.in(values),limit);
        }

        /**
     * Find records that have FINISHED_AT IN (values)
     * asynchronously
     */
        public Future> findManyByFinishedAt(Collection values) {
                return findManyByCondition(WTodo.W_TODO.FINISHED_AT.in(values));
        }

        /**
     * Find records that have FINISHED_AT IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByFinishedAt(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.FINISHED_AT.in(values),limit);
        }

        /**
     * Find records that have ACTIVE IN (values) asynchronously
     */
        public Future> findManyByActive(Collection values) {
                return findManyByCondition(WTodo.W_TODO.ACTIVE.in(values));
        }

        /**
     * Find records that have ACTIVE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByActive(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.ACTIVE.in(values),limit);
        }

        /**
     * Find records that have SIGMA IN (values) asynchronously
     */
        public Future> findManyBySigma(Collection values) {
                return findManyByCondition(WTodo.W_TODO.SIGMA.in(values));
        }

        /**
     * Find records that have SIGMA IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyBySigma(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.SIGMA.in(values),limit);
        }

        /**
     * Find records that have METADATA IN (values) asynchronously
     */
        public Future> findManyByMetadata(Collection values) {
                return findManyByCondition(WTodo.W_TODO.METADATA.in(values));
        }

        /**
     * Find records that have METADATA IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByMetadata(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.METADATA.in(values),limit);
        }

        /**
     * Find records that have LANGUAGE IN (values) asynchronously
     */
        public Future> findManyByLanguage(Collection values) {
                return findManyByCondition(WTodo.W_TODO.LANGUAGE.in(values));
        }

        /**
     * Find records that have LANGUAGE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByLanguage(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.LANGUAGE.in(values),limit);
        }

        /**
     * Find records that have CREATED_AT IN (values) asynchronously
     */
        public Future> findManyByCreatedAt(Collection values) {
                return findManyByCondition(WTodo.W_TODO.CREATED_AT.in(values));
        }

        /**
     * Find records that have CREATED_AT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByCreatedAt(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.CREATED_AT.in(values),limit);
        }

        /**
     * Find records that have CREATED_BY IN (values) asynchronously
     */
        public Future> findManyByCreatedBy(Collection values) {
                return findManyByCondition(WTodo.W_TODO.CREATED_BY.in(values));
        }

        /**
     * Find records that have CREATED_BY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByCreatedBy(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.CREATED_BY.in(values),limit);
        }

        /**
     * Find records that have UPDATED_AT IN (values) asynchronously
     */
        public Future> findManyByUpdatedAt(Collection values) {
                return findManyByCondition(WTodo.W_TODO.UPDATED_AT.in(values));
        }

        /**
     * Find records that have UPDATED_AT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByUpdatedAt(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.UPDATED_AT.in(values),limit);
        }

        /**
     * Find records that have UPDATED_BY IN (values) asynchronously
     */
        public Future> findManyByUpdatedBy(Collection values) {
                return findManyByCondition(WTodo.W_TODO.UPDATED_BY.in(values));
        }

        /**
     * Find records that have UPDATED_BY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByUpdatedBy(Collection values, int limit) {
                return findManyByCondition(WTodo.W_TODO.UPDATED_BY.in(values),limit);
        }

        @Override
        public JDBCClassicQueryExecutor queryExecutor(){
                return (JDBCClassicQueryExecutor) super.queryExecutor();
        }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy