Package cn.vertxup.workflow.domain.tables.daos

Class WTicketDao

    • Constructor Detail

      • WTicketDao

        public WTicketDao​(org.jooq.Configuration configuration,
                  io.vertx.core.Vertx vertx)
        Parameters:
        configuration - The ConfigRunner used for rendering and query execution. * @param vertx the vertx instance

    • Method Detail

      • findManyBySerial

        public io.vertx.core.Future<List<WTicket>> findManyBySerial​(Collection<String> values)
        Find records that have SERIAL IN (values) asynchronously

      • findManyBySerial

        public io.vertx.core.Future<List<WTicket>> findManyBySerial​(Collection<String> values,
                                                            int limit)
        Find records that have SERIAL IN (values) asynchronously limited by the given limit

      • findManyByName

        public io.vertx.core.Future<List<WTicket>> findManyByName​(Collection<String> values)
        Find records that have NAME IN (values) asynchronously

      • findManyByName

        public io.vertx.core.Future<List<WTicket>> findManyByName​(Collection<String> values,
                                                          int limit)
        Find records that have NAME IN (values) asynchronously limited by the given limit

      • findManyByCode

        public io.vertx.core.Future<List<WTicket>> findManyByCode​(Collection<String> values)
        Find records that have CODE IN (values) asynchronously

      • findManyByCode

        public io.vertx.core.Future<List<WTicket>> findManyByCode​(Collection<String> values,
                                                          int limit)
        Find records that have CODE IN (values) asynchronously limited by the given limit

      • findManyByType

        public io.vertx.core.Future<List<WTicket>> findManyByType​(Collection<String> values)
        Find records that have TYPE IN (values) asynchronously

      • findManyByType

        public io.vertx.core.Future<List<WTicket>> findManyByType​(Collection<String> values,
                                                          int limit)
        Find records that have TYPE IN (values) asynchronously limited by the given limit

      • findManyByPhase

        public io.vertx.core.Future<List<WTicket>> findManyByPhase​(Collection<String> values)
        Find records that have PHASE IN (values) asynchronously

      • findManyByPhase

        public io.vertx.core.Future<List<WTicket>> findManyByPhase​(Collection<String> values,
                                                           int limit)
        Find records that have PHASE IN (values) asynchronously limited by the given limit

      • findManyByModelId

        public io.vertx.core.Future<List<WTicket>> findManyByModelId​(Collection<String> values)
        Find records that have MODEL_ID IN (values) asynchronously

      • findManyByModelId

        public io.vertx.core.Future<List<WTicket>> findManyByModelId​(Collection<String> values,
                                                             int limit)
        Find records that have MODEL_ID IN (values) asynchronously limited by the given limit

      • findManyByModelKey

        public io.vertx.core.Future<List<WTicket>> findManyByModelKey​(Collection<String> values)
        Find records that have MODEL_KEY IN (values) asynchronously

      • findManyByModelKey

        public io.vertx.core.Future<List<WTicket>> findManyByModelKey​(Collection<String> values,
                                                              int limit)
        Find records that have MODEL_KEY IN (values) asynchronously limited by the given limit

      • findManyByModelCategory

        public io.vertx.core.Future<List<WTicket>> findManyByModelCategory​(Collection<String> values)
        Find records that have MODEL_CATEGORY IN (values) asynchronously

      • findManyByModelCategory

        public io.vertx.core.Future<List<WTicket>> findManyByModelCategory​(Collection<String> values,
                                                                   int limit)
        Find records that have MODEL_CATEGORY IN (values) asynchronously limited by the given limit

      • findManyByModelComponent

        public io.vertx.core.Future<List<WTicket>> findManyByModelComponent​(Collection<String> values)
        Find records that have MODEL_COMPONENT IN (values) asynchronously

      • findManyByModelComponent

        public io.vertx.core.Future<List<WTicket>> findManyByModelComponent​(Collection<String> values,
                                                                    int limit)
        Find records that have MODEL_COMPONENT IN (values) asynchronously limited by the given limit

      • findManyByModelChild

        public io.vertx.core.Future<List<WTicket>> findManyByModelChild​(Collection<String> values)
        Find records that have MODEL_CHILD IN (values) asynchronously

      • findManyByModelChild

        public io.vertx.core.Future<List<WTicket>> findManyByModelChild​(Collection<String> values,
                                                                int limit)
        Find records that have MODEL_CHILD IN (values) asynchronously limited by the given limit

      • findManyByQuantity

        public io.vertx.core.Future<List<WTicket>> findManyByQuantity​(Collection<Integer> values)
        Find records that have QUANTITY IN (values) asynchronously

      • findManyByQuantity

        public io.vertx.core.Future<List<WTicket>> findManyByQuantity​(Collection<Integer> values,
                                                              int limit)
        Find records that have QUANTITY IN (values) asynchronously limited by the given limit

      • findManyByFlowDefinitionKey

        public io.vertx.core.Future<List<WTicket>> findManyByFlowDefinitionKey​(Collection<String> values)
        Find records that have FLOW_DEFINITION_KEY IN (values) asynchronously

      • findManyByFlowDefinitionKey

        public io.vertx.core.Future<List<WTicket>> findManyByFlowDefinitionKey​(Collection<String> values,
                                                                       int limit)
        Find records that have FLOW_DEFINITION_KEY IN (values) asynchronously limited by the given limit

      • findManyByFlowDefinitionId

        public io.vertx.core.Future<List<WTicket>> findManyByFlowDefinitionId​(Collection<String> values)
        Find records that have FLOW_DEFINITION_ID IN (values) asynchronously

      • findManyByFlowDefinitionId

        public io.vertx.core.Future<List<WTicket>> findManyByFlowDefinitionId​(Collection<String> values,
                                                                      int limit)
        Find records that have FLOW_DEFINITION_ID IN (values) asynchronously limited by the given limit

      • findManyByFlowInstanceId

        public io.vertx.core.Future<List<WTicket>> findManyByFlowInstanceId​(Collection<String> values)
        Find records that have FLOW_INSTANCE_ID IN (values) asynchronously

      • findManyByFlowInstanceId

        public io.vertx.core.Future<List<WTicket>> findManyByFlowInstanceId​(Collection<String> values,
                                                                    int limit)
        Find records that have FLOW_INSTANCE_ID IN (values) asynchronously limited by the given limit

      • findManyByFlowEnd

        public io.vertx.core.Future<List<WTicket>> findManyByFlowEnd​(Collection<Boolean> values)
        Find records that have FLOW_END IN (values) asynchronously

      • findManyByFlowEnd

        public io.vertx.core.Future<List<WTicket>> findManyByFlowEnd​(Collection<Boolean> values,
                                                             int limit)
        Find records that have FLOW_END IN (values) asynchronously limited by the given limit

      • findManyByTitle

        public io.vertx.core.Future<List<WTicket>> findManyByTitle​(Collection<String> values)
        Find records that have TITLE IN (values) asynchronously

      • findManyByTitle

        public io.vertx.core.Future<List<WTicket>> findManyByTitle​(Collection<String> values,
                                                           int limit)
        Find records that have TITLE IN (values) asynchronously limited by the given limit

      • findManyByDescription

        public io.vertx.core.Future<List<WTicket>> findManyByDescription​(Collection<String> values)
        Find records that have DESCRIPTION IN (values) asynchronously

      • findManyByDescription

        public io.vertx.core.Future<List<WTicket>> findManyByDescription​(Collection<String> values,
                                                                 int limit)
        Find records that have DESCRIPTION IN (values) asynchronously limited by the given limit

      • findManyByCatalog

        public io.vertx.core.Future<List<WTicket>> findManyByCatalog​(Collection<String> values)
        Find records that have CATALOG IN (values) asynchronously

      • findManyByCatalog

        public io.vertx.core.Future<List<WTicket>> findManyByCatalog​(Collection<String> values,
                                                             int limit)
        Find records that have CATALOG IN (values) asynchronously limited by the given limit

      • findManyByCategory

        public io.vertx.core.Future<List<WTicket>> findManyByCategory​(Collection<String> values)
        Find records that have CATEGORY IN (values) asynchronously

      • findManyByCategory

        public io.vertx.core.Future<List<WTicket>> findManyByCategory​(Collection<String> values,
                                                              int limit)
        Find records that have CATEGORY IN (values) asynchronously limited by the given limit

      • findManyByCategorySub

        public io.vertx.core.Future<List<WTicket>> findManyByCategorySub​(Collection<String> values)
        Find records that have CATEGORY_SUB IN (values) asynchronously

      • findManyByCategorySub

        public io.vertx.core.Future<List<WTicket>> findManyByCategorySub​(Collection<String> values,
                                                                 int limit)
        Find records that have CATEGORY_SUB IN (values) asynchronously limited by the given limit

      • findManyByOwner

        public io.vertx.core.Future<List<WTicket>> findManyByOwner​(Collection<String> values)
        Find records that have OWNER IN (values) asynchronously

      • findManyByOwner

        public io.vertx.core.Future<List<WTicket>> findManyByOwner​(Collection<String> values,
                                                           int limit)
        Find records that have OWNER IN (values) asynchronously limited by the given limit

      • findManyBySupervisor

        public io.vertx.core.Future<List<WTicket>> findManyBySupervisor​(Collection<String> values)
        Find records that have SUPERVISOR IN (values) asynchronously

      • findManyBySupervisor

        public io.vertx.core.Future<List<WTicket>> findManyBySupervisor​(Collection<String> values,
                                                                int limit)
        Find records that have SUPERVISOR IN (values) asynchronously limited by the given limit

      • findManyByOpenBy

        public io.vertx.core.Future<List<WTicket>> findManyByOpenBy​(Collection<String> values)
        Find records that have OPEN_BY IN (values) asynchronously

      • findManyByOpenBy

        public io.vertx.core.Future<List<WTicket>> findManyByOpenBy​(Collection<String> values,
                                                            int limit)
        Find records that have OPEN_BY IN (values) asynchronously limited by the given limit

      • findManyByOpenAt

        public io.vertx.core.Future<List<WTicket>> findManyByOpenAt​(Collection<LocalDateTime> values)
        Find records that have OPEN_AT IN (values) asynchronously

      • findManyByOpenAt

        public io.vertx.core.Future<List<WTicket>> findManyByOpenAt​(Collection<LocalDateTime> values,
                                                            int limit)
        Find records that have OPEN_AT IN (values) asynchronously limited by the given limit

      • findManyByCancelBy

        public io.vertx.core.Future<List<WTicket>> findManyByCancelBy​(Collection<String> values)
        Find records that have CANCEL_BY IN (values) asynchronously

      • findManyByCancelBy

        public io.vertx.core.Future<List<WTicket>> findManyByCancelBy​(Collection<String> values,
                                                              int limit)
        Find records that have CANCEL_BY IN (values) asynchronously limited by the given limit

      • findManyByCancelAt

        public io.vertx.core.Future<List<WTicket>> findManyByCancelAt​(Collection<LocalDateTime> values)
        Find records that have CANCEL_AT IN (values) asynchronously

      • findManyByCancelAt

        public io.vertx.core.Future<List<WTicket>> findManyByCancelAt​(Collection<LocalDateTime> values,
                                                              int limit)
        Find records that have CANCEL_AT IN (values) asynchronously limited by the given limit

      • findManyByCloseBy

        public io.vertx.core.Future<List<WTicket>> findManyByCloseBy​(Collection<String> values)
        Find records that have CLOSE_BY IN (values) asynchronously

      • findManyByCloseBy

        public io.vertx.core.Future<List<WTicket>> findManyByCloseBy​(Collection<String> values,
                                                             int limit)
        Find records that have CLOSE_BY IN (values) asynchronously limited by the given limit

      • findManyByCloseAt

        public io.vertx.core.Future<List<WTicket>> findManyByCloseAt​(Collection<LocalDateTime> values)
        Find records that have CLOSE_AT IN (values) asynchronously

      • findManyByCloseAt

        public io.vertx.core.Future<List<WTicket>> findManyByCloseAt​(Collection<LocalDateTime> values,
                                                             int limit)
        Find records that have CLOSE_AT IN (values) asynchronously limited by the given limit

      • findManyByCloseSolution

        public io.vertx.core.Future<List<WTicket>> findManyByCloseSolution​(Collection<String> values)
        Find records that have CLOSE_SOLUTION IN (values) asynchronously

      • findManyByCloseSolution

        public io.vertx.core.Future<List<WTicket>> findManyByCloseSolution​(Collection<String> values,
                                                                   int limit)
        Find records that have CLOSE_SOLUTION IN (values) asynchronously limited by the given limit

      • findManyByCloseCode

        public io.vertx.core.Future<List<WTicket>> findManyByCloseCode​(Collection<String> values)
        Find records that have CLOSE_CODE IN (values) asynchronously

      • findManyByCloseCode

        public io.vertx.core.Future<List<WTicket>> findManyByCloseCode​(Collection<String> values,
                                                               int limit)
        Find records that have CLOSE_CODE IN (values) asynchronously limited by the given limit

      • findManyByCloseKb

        public io.vertx.core.Future<List<WTicket>> findManyByCloseKb​(Collection<String> values)
        Find records that have CLOSE_KB IN (values) asynchronously

      • findManyByCloseKb

        public io.vertx.core.Future<List<WTicket>> findManyByCloseKb​(Collection<String> values,
                                                             int limit)
        Find records that have CLOSE_KB IN (values) asynchronously limited by the given limit

      • findManyByActive

        public io.vertx.core.Future<List<WTicket>> findManyByActive​(Collection<Boolean> values)
        Find records that have ACTIVE IN (values) asynchronously

      • findManyByActive

        public io.vertx.core.Future<List<WTicket>> findManyByActive​(Collection<Boolean> values,
                                                            int limit)
        Find records that have ACTIVE IN (values) asynchronously limited by the given limit

      • findManyBySigma

        public io.vertx.core.Future<List<WTicket>> findManyBySigma​(Collection<String> values)
        Find records that have SIGMA IN (values) asynchronously

      • findManyBySigma

        public io.vertx.core.Future<List<WTicket>> findManyBySigma​(Collection<String> values,
                                                           int limit)
        Find records that have SIGMA IN (values) asynchronously limited by the given limit

      • findManyByMetadata

        public io.vertx.core.Future<List<WTicket>> findManyByMetadata​(Collection<String> values)
        Find records that have METADATA IN (values) asynchronously

      • findManyByMetadata

        public io.vertx.core.Future<List<WTicket>> findManyByMetadata​(Collection<String> values,
                                                              int limit)
        Find records that have METADATA IN (values) asynchronously limited by the given limit

      • findManyByLanguage

        public io.vertx.core.Future<List<WTicket>> findManyByLanguage​(Collection<String> values)
        Find records that have LANGUAGE IN (values) asynchronously

      • findManyByLanguage

        public io.vertx.core.Future<List<WTicket>> findManyByLanguage​(Collection<String> values,
                                                              int limit)
        Find records that have LANGUAGE IN (values) asynchronously limited by the given limit

      • findManyByCreatedAt

        public io.vertx.core.Future<List<WTicket>> findManyByCreatedAt​(Collection<LocalDateTime> values)
        Find records that have CREATED_AT IN (values) asynchronously

      • findManyByCreatedAt

        public io.vertx.core.Future<List<WTicket>> findManyByCreatedAt​(Collection<LocalDateTime> values,
                                                               int limit)
        Find records that have CREATED_AT IN (values) asynchronously limited by the given limit

      • findManyByCreatedBy

        public io.vertx.core.Future<List<WTicket>> findManyByCreatedBy​(Collection<String> values)
        Find records that have CREATED_BY IN (values) asynchronously

      • findManyByCreatedBy

        public io.vertx.core.Future<List<WTicket>> findManyByCreatedBy​(Collection<String> values,
                                                               int limit)
        Find records that have CREATED_BY IN (values) asynchronously limited by the given limit

      • findManyByUpdatedAt

        public io.vertx.core.Future<List<WTicket>> findManyByUpdatedAt​(Collection<LocalDateTime> values)
        Find records that have UPDATED_AT IN (values) asynchronously

      • findManyByUpdatedAt

        public io.vertx.core.Future<List<WTicket>> findManyByUpdatedAt​(Collection<LocalDateTime> values,
                                                               int limit)
        Find records that have UPDATED_AT IN (values) asynchronously limited by the given limit

      • findManyByUpdatedBy

        public io.vertx.core.Future<List<WTicket>> findManyByUpdatedBy​(Collection<String> values)
        Find records that have UPDATED_BY IN (values) asynchronously

      • findManyByUpdatedBy

        public io.vertx.core.Future<List<WTicket>> findManyByUpdatedBy​(Collection<String> values,
                                                               int limit)
        Find records that have UPDATED_BY IN (values) asynchronously limited by the given limit

      • queryExecutor

        public io.github.jklingsporn.vertx.jooq.classic.jdbc.JDBCClassicQueryExecutor<WTicketRecord,​WTicket,​String> queryExecutor()
        Specified by:
        queryExecutor in interface io.github.jklingsporn.vertx.jooq.shared.internal.GenericVertxDAO<WTicketRecord,​WTicket,​String,​io.vertx.core.Future<List<WTicket>>,​io.vertx.core.Future<WTicket>,​io.vertx.core.Future<Integer>,​io.vertx.core.Future<String>>
        Overrides:
        queryExecutor in class io.github.jklingsporn.vertx.jooq.shared.internal.AbstractVertxDAO<WTicketRecord,​WTicket,​String,​io.vertx.core.Future<List<WTicket>>,​io.vertx.core.Future<WTicket>,​io.vertx.core.Future<Integer>,​io.vertx.core.Future<String>>