cn.vertxup.erp.domain.tables.daos.EIdentityDao Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of zero-erp Show documentation
There is a newer version: 0.9.0
/*
 * This file is generated by jOOQ.
 */
package cn.vertxup.erp.domain.tables.daos;


import cn.vertxup.erp.domain.tables.EIdentity;
import cn.vertxup.erp.domain.tables.records.EIdentityRecord;

import io.github.jklingsporn.vertx.jooq.shared.internal.AbstractVertxDAO;

import java.time.LocalDateTime;
import java.util.Collection;

import org.jooq.Configuration;


import java.util.List;
import io.vertx.core.Future;
import io.github.jklingsporn.vertx.jooq.classic.jdbc.JDBCClassicQueryExecutor;
/**
 * This class is generated by jOOQ.
 */
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public class EIdentityDao 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 EIdentityDao(Configuration configuration, io.vertx.core.Vertx vertx) {
                super(EIdentity.E_IDENTITY, cn.vertxup.erp.domain.tables.pojos.EIdentity.class, new JDBCClassicQueryExecutor(configuration,cn.vertxup.erp.domain.tables.pojos.EIdentity.class,vertx));
        }

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

        /**
     * Find records that have CODE IN (values) asynchronously
     */
        public Future> findManyByCode(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.CODE.in(values),limit);
        }

        /**
     * Find records that have TYPE IN (values) asynchronously
     */
        public Future> findManyByType(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.TYPE.in(values),limit);
        }

        /**
     * Find records that have STATUS IN (values) asynchronously
     */
        public Future> findManyByStatus(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.STATUS.in(values),limit);
        }

        /**
     * Find records that have COUNTRY IN (values) asynchronously
     */
        public Future> findManyByCountry(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.COUNTRY.in(values));
        }

        /**
     * Find records that have COUNTRY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByCountry(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.COUNTRY.in(values),limit);
        }

        /**
     * Find records that have NATIVE_PLACE IN (values)
     * asynchronously
     */
        public Future> findManyByNativePlace(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.NATIVE_PLACE.in(values));
        }

        /**
     * Find records that have NATIVE_PLACE IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByNativePlace(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.NATIVE_PLACE.in(values),limit);
        }

        /**
     * Find records that have NATION IN (values) asynchronously
     */
        public Future> findManyByNation(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.NATION.in(values));
        }

        /**
     * Find records that have NATION IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByNation(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.NATION.in(values),limit);
        }

        /**
     * Find records that have ADDRESS IN (values) asynchronously
     */
        public Future> findManyByAddress(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.ADDRESS.in(values));
        }

        /**
     * Find records that have ADDRESS IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByAddress(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.ADDRESS.in(values),limit);
        }

        /**
     * Find records that have REALNAME IN (values) asynchronously
     */
        public Future> findManyByRealname(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.REALNAME.in(values));
        }

        /**
     * Find records that have REALNAME IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByRealname(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.REALNAME.in(values),limit);
        }

        /**
     * Find records that have BIRTHDAY IN (values) asynchronously
     */
        public Future> findManyByBirthday(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.BIRTHDAY.in(values));
        }

        /**
     * Find records that have BIRTHDAY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByBirthday(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.BIRTHDAY.in(values),limit);
        }

        /**
     * Find records that have DRIVER_LICENSE IN (values)
     * asynchronously
     */
        public Future> findManyByDriverLicense(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.DRIVER_LICENSE.in(values));
        }

        /**
     * Find records that have DRIVER_LICENSE IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByDriverLicense(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.DRIVER_LICENSE.in(values),limit);
        }

        /**
     * Find records that have CAR_PLATE IN (values) asynchronously
     */
        public Future> findManyByCarPlate(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.CAR_PLATE.in(values));
        }

        /**
     * Find records that have CAR_PLATE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByCarPlate(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.CAR_PLATE.in(values),limit);
        }

        /**
     * Find records that have PASSPORT IN (values) asynchronously
     */
        public Future> findManyByPassport(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.PASSPORT.in(values));
        }

        /**
     * Find records that have PASSPORT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByPassport(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.PASSPORT.in(values),limit);
        }

        /**
     * Find records that have GENDER IN (values) asynchronously
     */
        public Future> findManyByGender(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.GENDER.in(values));
        }

        /**
     * Find records that have GENDER IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByGender(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.GENDER.in(values),limit);
        }

        /**
     * Find records that have MARITAL IN (values) asynchronously
     */
        public Future> findManyByMarital(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.MARITAL.in(values));
        }

        /**
     * Find records that have MARITAL IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByMarital(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.MARITAL.in(values),limit);
        }

        /**
     * Find records that have CONTACT_MOBILE IN (values)
     * asynchronously
     */
        public Future> findManyByContactMobile(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_MOBILE.in(values));
        }

        /**
     * Find records that have CONTACT_MOBILE IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByContactMobile(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_MOBILE.in(values),limit);
        }

        /**
     * Find records that have CONTACT_PHONE IN (values)
     * asynchronously
     */
        public Future> findManyByContactPhone(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_PHONE.in(values));
        }

        /**
     * Find records that have CONTACT_PHONE IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByContactPhone(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_PHONE.in(values),limit);
        }

        /**
     * Find records that have CONTACT_ADDRESS IN (values)
     * asynchronously
     */
        public Future> findManyByContactAddress(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_ADDRESS.in(values));
        }

        /**
     * Find records that have CONTACT_ADDRESS IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByContactAddress(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_ADDRESS.in(values),limit);
        }

        /**
     * Find records that have CONTACT_EMAIL IN (values)
     * asynchronously
     */
        public Future> findManyByContactEmail(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_EMAIL.in(values));
        }

        /**
     * Find records that have CONTACT_EMAIL IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByContactEmail(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.CONTACT_EMAIL.in(values),limit);
        }

        /**
     * Find records that have URGENT_NAME IN (values)
     * asynchronously
     */
        public Future> findManyByUrgentName(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.URGENT_NAME.in(values));
        }

        /**
     * Find records that have URGENT_NAME IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByUrgentName(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.URGENT_NAME.in(values),limit);
        }

        /**
     * Find records that have URGENT_PHONE IN (values)
     * asynchronously
     */
        public Future> findManyByUrgentPhone(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.URGENT_PHONE.in(values));
        }

        /**
     * Find records that have URGENT_PHONE IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByUrgentPhone(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.URGENT_PHONE.in(values),limit);
        }

        /**
     * Find records that have EC_QQ IN (values) asynchronously
     */
        public Future> findManyByEcQq(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.EC_QQ.in(values));
        }

        /**
     * Find records that have EC_QQ IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByEcQq(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.EC_QQ.in(values),limit);
        }

        /**
     * Find records that have EC_ALIPAY IN (values) asynchronously
     */
        public Future> findManyByEcAlipay(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.EC_ALIPAY.in(values));
        }

        /**
     * Find records that have EC_ALIPAY IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByEcAlipay(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.EC_ALIPAY.in(values),limit);
        }

        /**
     * Find records that have EC_WECHAT IN (values) asynchronously
     */
        public Future> findManyByEcWechat(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.EC_WECHAT.in(values));
        }

        /**
     * Find records that have EC_WECHAT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByEcWechat(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.EC_WECHAT.in(values),limit);
        }

        /**
     * Find records that have IDC_TYPE IN (values) asynchronously
     */
        public Future> findManyByIdcType(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_TYPE.in(values));
        }

        /**
     * Find records that have IDC_TYPE IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByIdcType(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_TYPE.in(values),limit);
        }

        /**
     * Find records that have IDC_NUMBER IN (values) asynchronously
     */
        public Future> findManyByIdcNumber(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_NUMBER.in(values));
        }

        /**
     * Find records that have IDC_NUMBER IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByIdcNumber(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_NUMBER.in(values),limit);
        }

        /**
     * Find records that have IDC_ADDRESS IN (values)
     * asynchronously
     */
        public Future> findManyByIdcAddress(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_ADDRESS.in(values));
        }

        /**
     * Find records that have IDC_ADDRESS IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByIdcAddress(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_ADDRESS.in(values),limit);
        }

        /**
     * Find records that have IDC_EXPIRED_AT IN (values)
     * asynchronously
     */
        public Future> findManyByIdcExpiredAt(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_EXPIRED_AT.in(values));
        }

        /**
     * Find records that have IDC_EXPIRED_AT IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByIdcExpiredAt(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_EXPIRED_AT.in(values),limit);
        }

        /**
     * Find records that have IDC_FRONT IN (values) asynchronously
     */
        public Future> findManyByIdcFront(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_FRONT.in(values));
        }

        /**
     * Find records that have IDC_FRONT IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByIdcFront(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_FRONT.in(values),limit);
        }

        /**
     * Find records that have IDC_BACK IN (values) asynchronously
     */
        public Future> findManyByIdcBack(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_BACK.in(values));
        }

        /**
     * Find records that have IDC_BACK IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByIdcBack(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_BACK.in(values),limit);
        }

        /**
     * Find records that have IDC_ISSUER IN (values) asynchronously
     */
        public Future> findManyByIdcIssuer(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_ISSUER.in(values));
        }

        /**
     * Find records that have IDC_ISSUER IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByIdcIssuer(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_ISSUER.in(values),limit);
        }

        /**
     * Find records that have IDC_ISSUE_AT IN (values)
     * asynchronously
     */
        public Future> findManyByIdcIssueAt(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_ISSUE_AT.in(values));
        }

        /**
     * Find records that have IDC_ISSUE_AT IN (values)
     * asynchronously limited by the given limit
     */
        public Future> findManyByIdcIssueAt(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.IDC_ISSUE_AT.in(values),limit);
        }

        /**
     * Find records that have VERIFIED IN (values) asynchronously
     */
        public Future> findManyByVerified(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.VERIFIED.in(values));
        }

        /**
     * Find records that have VERIFIED IN (values) asynchronously
     * limited by the given limit
     */
        public Future> findManyByVerified(Collection values, int limit) {
                return findManyByCondition(EIdentity.E_IDENTITY.VERIFIED.in(values),limit);
        }

        /**
     * Find records that have METADATA IN (values) asynchronously
     */
        public Future> findManyByMetadata(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.METADATA.in(values),limit);
        }

        /**
     * Find records that have ACTIVE IN (values) asynchronously
     */
        public Future> findManyByActive(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.ACTIVE.in(values),limit);
        }

        /**
     * Find records that have SIGMA IN (values) asynchronously
     */
        public Future> findManyBySigma(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.SIGMA.in(values),limit);
        }

        /**
     * Find records that have LANGUAGE IN (values) asynchronously
     */
        public Future> findManyByLanguage(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.LANGUAGE.in(values),limit);
        }

        /**
     * Find records that have CREATED_AT IN (values) asynchronously
     */
        public Future> findManyByCreatedAt(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.CREATED_AT.in(values),limit);
        }

        /**
     * Find records that have CREATED_BY IN (values) asynchronously
     */
        public Future> findManyByCreatedBy(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.CREATED_BY.in(values),limit);
        }

        /**
     * Find records that have UPDATED_AT IN (values) asynchronously
     */
        public Future> findManyByUpdatedAt(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.UPDATED_AT.in(values),limit);
        }

        /**
     * Find records that have UPDATED_BY IN (values) asynchronously
     */
        public Future> findManyByUpdatedBy(Collection values) {
                return findManyByCondition(EIdentity.E_IDENTITY.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(EIdentity.E_IDENTITY.UPDATED_BY.in(values),limit);
        }

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