generator-jhipster 8.0.0-beta.3 → 8.0.0-rc.1

package/dist/generators/server/templates/src/main/java/_package_/_entityPackage_/repository/_entityClass_Repository_reactive.java.ejs

@@ -0,0 +1,168 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= entityAbsolutePackage %>.repository;
+
+import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+import <%= entityAbsolutePackage %>.domain.criteria.<%= entityClass %>Criteria;
+<%_ }  _%>
+<%_ if (databaseTypeCassandra) { _%>
+import org.springframework.data.cassandra.repository.ReactiveCassandraRepository;
+<%_ } _%>
+<%_ if (databaseTypeNeo4j) { _%>
+import org.springframework.data.neo4j.repository.ReactiveNeo4jRepository;
+import org.springframework.data.neo4j.repository.query.Query;
+<%_ } _%>
+<%_ if (!paginationNo || implementsEagerLoadApis || databaseTypeSql) { _%>
+import org.springframework.data.domain.Pageable;
+<%_ } _%>
+<%_ if (databaseTypeSql) { _%>
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.data.relational.core.query.Criteria;
+<%_ } _%>
+<%_ if (databaseTypeMongodb) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
+import org.springframework.data.mongodb.repository.Query;
+  <%_ } _%>
+import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
+<%_ } _%>
+import org.springframework.stereotype.Repository;
+<%_ if (databaseTypeSql || !paginationNo || implementsEagerLoadApis) { _%>
+import reactor.core.publisher.Flux;
+<%_ } _%>
+<%_ if (implementsEagerLoadApis || databaseTypeSql) { _%>
+import reactor.core.publisher.Mono;
+<%_ } _%>
+<%_ if (primaryKey.typeUUID) { _%>
+
+import java.util.UUID;
+<%_ } _%>
+
+/**
+ * <%= springDataDescription %> repository for the <%= persistClass %> entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) { %>ReactiveCrud<% } if (databaseTypeMongodb) { %>ReactiveMongo<% } if (databaseTypeNeo4j) { %>ReactiveNeo4j<% } if (databaseTypeCassandra) { %>ReactiveCassandra<% } %>Repository<<%= persistClass %>, <%= primaryKey.type %>><% if (databaseTypeSql) { %>, <%= entityClass %>RepositoryInternal<% } %> {
+
+<%_ if (!paginationNo) { _%>
+    Flux<<%= persistClass %>> findAllBy(Pageable pageable);
+<%_ } _%>
+<%_ if (implementsEagerLoadApis) { _%>
+  <%_ if (databaseTypeMongodb) { _%>
+
+    @Query("<%= (databaseTypeMongodb) ? '{}' : '#{#n1ql.selectEntity} WHERE #{#n1ql.filter}' %>")
+    Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable pageable);
+
+    @Query("<%= (databaseTypeMongodb) ? '{}' : '#{#n1ql.selectEntity} WHERE #{#n1ql.filter}' %>")
+    Flux<<%= persistClass %>> findAllWithEagerRelationships();
+
+    @Query("<%- (databaseTypeMongodb) ? "{'id': ?0}" : "#{#n1ql.selectEntity} USE KEYS $1 WHERE #{#n1ql.filter}" %>")
+    Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id);
+  <%_ } _%>
+  <%_ if (databaseTypeNeo4j) { _%>
+    @Query("MATCH (n:<%= persistClass %>)<-[]-(m) RETURN n,m")
+    Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable pageable);
+
+    @Query("MATCH (n:<%= persistClass %>)<-[]-(m) RETURN n,m")
+    Flux<<%= persistClass %>> findAllWithEagerRelationships();
+
+    @Query("MATCH (e:<%= persistClass %> {id: $id}) RETURN e")
+    Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id);
+  <%_ } _%>
+<%_ } _%>
+<%_ if (databaseTypeSql) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
+
+    @Override
+    Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id);
+
+    @Override
+    Flux<<%= persistClass %>> findAllWithEagerRelationships();
+
+    @Override
+    Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable page);
+
+  <%_ } _%>
+
+  <%_ for (const relationship of relationships) {
+    let relationshipName = relationship.relationshipName;
+    let ownerSide = relationship.ownerSide; _%>
+    <%_ if (relationship.relationshipManyToOne || (relationship.relationshipOneToOne && ownerSide)) { _%>
+
+    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= relationship.joinColumnNames[0] %> = :id")
+    Flux<<%= persistClass %>> findBy<%= relationship.relationshipNameCapitalized %>(<%= primaryKey.type %> id);
+
+    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= relationship.joinColumnNames[0] %> IS NULL")
+    Flux<<%= persistClass %>> findAllWhere<%= relationship.relationshipNameCapitalized %>IsNull();
+    <%_ } else if (relationship.shouldWriteJoinTable) { _%>
+
+    @Query("SELECT entity.* FROM <%= entityTableName %> entity JOIN <%= relationship.joinTable.name %> joinTable ON entity.<%= primaryKey.fields[0].columnName %> = joinTable.<%= relationship.joinColumnNames[0] %> WHERE joinTable.<%= relationship.joinColumnNames[0] %> = :id")
+    Flux<<%= persistClass %>> findBy<%= relationship.relationshipNameCapitalized %>(<%= primaryKey.type %> id);
+    <%_ } else if (relationship.relationshipOneToOne && !ownerSide) {
+        let otherEntityRelationshipName = relationship.otherEntityRelationshipName;
+        let otherEntityTableName = relationship.otherEntityTableName;
+      _%>
+
+    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= primaryKey.fields[0].columnName  %> not in (select <%= relationship.joinColumnNames[0]%> from <%= otherEntityTableName %>)")
+    Flux<<%= persistClass %>> findAllWhere<%= relationship.relationshipNameCapitalized %>IsNull();
+    <%_ } _%>
+  <%_ } _%>
+
+    @Override
+    <S extends <%= persistClass %>> Mono<S> save(S entity);
+
+    @Override
+    Flux<<%= persistClass %>> findAll();
+
+    @Override
+    Mono<<%= persistClass %>> findById(<%= primaryKey.type %> id);
+
+    @Override
+    Mono<Void> deleteById(<%= primaryKey.type %> id);
+}
+
+interface <%= entityClass %>RepositoryInternal {
+    <S extends <%= persistClass %>> Mono<S> save(S entity);
+
+    Flux<<%= persistClass %>> findAllBy(Pageable pageable);
+
+    Flux<<%= persistClass %>> findAll();
+
+    Mono<<%= persistClass %>> findById(<%= primaryKey.type %> id);
+    // this is not supported at the moment because of https://github.com/jhipster/generator-jhipster/issues/18269
+    // Flux<<%= persistClass %>> findAllBy(Pageable pageable, Criteria criteria);
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+    Flux<<%= persistClass %>> findByCriteria(<%= entityClass %>Criteria criteria, Pageable pageable);
+
+    Mono<Long> countByCriteria(<%= entityClass %>Criteria criteria);
+<%_ }  _%>
+  <%_ if (implementsEagerLoadApis) { _%>
+
+    Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id);
+
+    Flux<<%= persistClass %>> findAllWithEagerRelationships();
+
+    Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable page);
+
+    Mono<Void> deleteById(<%= primaryKey.type %> id);
+  <%_ } _%>
+<%_ } _%>
+}

package/dist/generators/server/templates/src/main/java/_package_/_entityPackage_/service/_entityClass_QueryService.java.ejs

@@ -0,0 +1,155 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= entityAbsolutePackage %>.service;
+
+<%_
+const serviceClassName = entityClass + 'QueryService';
+const instanceType = restClass;
+const instanceName = restInstance;
+const mapper = entityInstance  + 'Mapper';
+const dtoToEntity = mapper + '.'+ 'toEntity';
+const entityToDto = mapper + '.'+ 'toDto';
+const entityListToDto = mapper + '.' + 'toDto';
+const entityToDtoReference = mapper + '::'+ 'toDto';
+const repository = entityInstance  + 'Repository';
+const criteria = entityClass + 'Criteria';
+_%>
+import java.util.List;
+
+import jakarta.persistence.criteria.JoinType;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import tech.jhipster.service.QueryService;
+
+import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
+import <%= entityAbsolutePackage %>.domain.*; // for static metamodels
+import <%= entityAbsolutePackage %>.repository.<%= entityClass %>Repository;
+<%_ if (searchEngineElasticsearch) { _%>
+import <%= entityAbsolutePackage %>.repository.search.<%= entityClass %>SearchRepository;
+<%_ } _%>
+import <%= entityAbsolutePackage %>.service.criteria.<%= entityClass %>Criteria;
+<%_ if (dtoMapstruct) { _%>
+import <%= entityAbsolutePackage %>.service.dto.<%= dtoClass %>;
+import <%= entityAbsolutePackage %>.service.mapper.<%= entityClass %>Mapper;
+<%_ } _%>
+
+/**
+ * Service for executing complex queries for {@link <%= persistClass %>} entities in the database.
+ * The main input is a {@link <%= entityClass %>Criteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link <%= instanceType %>} or a {@link Page} of {@link <%= instanceType %>} which fulfills the criteria.
+ */
+@Service
+<%_ if (databaseTypeSql) { _%>
+@Transactional(readOnly = true)
+<%_ } _%>
+public class <%= serviceClassName %> extends QueryService<<%= persistClass %>> {
+
+    private final Logger log = LoggerFactory.getLogger(<%= serviceClassName %>.class);
+<%- include('../_partials_entity_/inject_template', {viaService: false, constructorName: serviceClassName, queryService: false, isUsingMapsId: false, mapsIdAssoc: null, isController: false}); -%>
+
+    /**
+     * Return a {@link List} of {@link <%= instanceType %>} which matches the criteria from the database.
+     * @param criteria The object which holds all the filters, which the entities should match.
+     * @return the matching entities.
+     */
+    @Transactional(readOnly = true)
+    public List<<%= instanceType %>> findByCriteria(<%= criteria %> criteria) {
+        log.debug("find by criteria : {}", criteria);
+        final Specification<<%= persistClass %>> specification = createSpecification(criteria);
+<%_ if (dtoMapstruct) { _%>
+        return <%= entityListToDto %>(<%= repository %>.findAll(specification));
+<%_ } else { _%>
+        return <%= repository %>.findAll(specification);
+<%_ } _%>
+    }
+
+    /**
+     * Return a {@link Page} of {@link <%= instanceType %>} which matches the criteria from the database.
+     * @param criteria The object which holds all the filters, which the entities should match.
+     * @param page The page, which should be returned.
+     * @return the matching entities.
+     */
+    @Transactional(readOnly = true)
+    public Page<<%= instanceType %>> findByCriteria(<%= criteria %> criteria, Pageable page) {
+        log.debug("find by criteria : {}, page: {}", criteria, page);
+        final Specification<<%= persistClass %>> specification = createSpecification(criteria);
+<%_ if (dtoMapstruct) { _%>
+        return <%= repository %>.findAll(specification, page)
+            .map(<%= entityToDtoReference %>);
+<%_ } else { _%>
+        return <%= repository %>.findAll(specification, page);
+<%_ } _%>
+    }
+
+    /**
+     * Return the number of matching entities in the database.
+     * @param criteria The object which holds all the filters, which the entities should match.
+     * @return the number of matching entities.
+     */
+    @Transactional(readOnly = true)
+    public long countByCriteria(<%= criteria %> criteria) {
+        log.debug("count by criteria : {}", criteria);
+        final Specification<<%= persistClass %>> specification = createSpecification(criteria);
+        return <%= repository %>.count(specification);
+    }
+
+    /**
+     * Function to convert {@link <%= criteria %>} to a {@link Specification}
+     * @param criteria The object which holds all the filters, which the entities should match.
+     * @return the matching {@link Specification} of the entity.
+     */
+    protected Specification<<%= persistClass %>> createSpecification(<%= criteria %> criteria) {
+        Specification<<%= persistClass %>> specification = Specification.where(null);
+        if (criteria != null) {
+            // This has to be called first, because the distinct method returns null
+            if (criteria.getDistinct() != null) {
+                specification = specification.and(distinct(criteria.getDistinct()));
+            }
+            if (criteria.get<%= primaryKey.nameCapitalized %>() != null) {
+                specification = specification.and(<%= this.getSpecificationBuilder(primaryKey.type) %>(criteria.get<%= primaryKey.nameCapitalized %>(), <%= persistClass %>_.<%= primaryKey.name %>));
+            }
+<%_
+fields.forEach((field) => {
+  if (field.id || field.transient) return;
+  if (field.filterableField) { _%>
+            if (criteria.get<%= field.fieldInJavaBeanMethod %>() != null) {
+                specification = specification.and(<%= this.getSpecificationBuilder(field.fieldType) %>(criteria.get<%= field.fieldInJavaBeanMethod %>(), <%= persistClass %>_.<%= field.fieldName %>));
+            }
+  <%_ }
+});
+
+relationships.forEach((relationship) => {
+  const metamodelFieldName = (relationship.relationshipManyToMany || relationship.relationshipOneToMany) ? relationship.relationshipFieldNamePlural : relationship.relationshipFieldName; _%>
+if (criteria.get<%= relationship.relationshipNameCapitalized %>Id() != null) {
+    specification = specification.and(buildSpecification(criteria.get<%= relationship.relationshipNameCapitalized %>Id(),
+        root -> root.join(<%= persistClass %>_.<%= metamodelFieldName %>, JoinType.LEFT).get(<%= relationship.otherEntity.persistClass %>_.<%= relationship.otherEntity.primaryKey.name %>)));
+}
+<%_ }); /* forEach */ _%>
+        }
+        return specification;
+    }
+}

package/dist/generators/server/templates/src/main/java/_package_/_entityPackage_/service/_entityClass_Service.java.ejs

@@ -0,0 +1,181 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= entityAbsolutePackage %>.service;
+
+<%_
+const instanceType = restClass;
+const instanceName = restInstance;
+const optionalOrMono = (reactive) ? 'Mono' : 'Optional';
+const listOrFlux = (reactive) ? 'Flux' : 'List';
+const pageOrFlux = (reactive) ? 'Flux' : 'Page';
+_%>
+<%_ if (dtoMapstruct) { _%>
+import <%= entityAbsolutePackage %>.service.dto.<%= dtoClass %>;
+<%_ } else { _%>
+import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
+<%_ } _%>
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+import <%= entityAbsolutePackage %>.domain.criteria.<%= entityClass %>Criteria;
+<%_ }  _%>
+<%_ if (!paginationNo || implementsEagerLoadApis) { _%>
+
+  <%_ if (!reactive) { _%>
+import org.springframework.data.domain.Page;
+  <%_ } _%>
+import org.springframework.data.domain.Pageable;
+<%_ } _%>
+<%_ if (reactive) { _%>
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+<%_ } _%>
+
+<%_ if (paginationNo || fieldsContainNoOwnerOneToOne) { _%>
+import java.util.List;
+<%_ } _%>
+<%_ if (!reactive) { _%>
+import java.util.Optional;
+<%_ } _%>
+<%_ if (primaryKey.typeUUID) { _%>
+import java.util.UUID;
+<%_ } _%>
+
+/**
+ * Service Interface for managing {@link <%= entityAbsoluteClass %>}.
+ */
+public interface <%= entityClass %>Service {
+
+    /**
+     * Save a <%= entityInstance %>.
+     *
+     * @param <%= instanceName %> the entity to save.
+     * @return the persisted entity.
+     */
+    <% if (reactive) { %>Mono<<% } %><%= instanceType %><% if (reactive) { %>><% } %> save(<%= instanceType %> <%= instanceName %>);
+
+    /**
+     * Updates a <%= entityInstance %>.
+     *
+     * @param <%= instanceName %> the entity to update.
+     * @return the persisted entity.
+     */
+     <% if (reactive) { %>Mono<<% } %><%= instanceType %><% if (reactive) { %>><% } %> update(<%= instanceType %> <%= instanceName %>);
+
+    /**
+     * Partially updates a <%= entityInstance %>.
+     *
+     * @param <%= instanceName %> the entity to update partially.
+     * @return the persisted entity.
+     */
+    <% if (reactive) { %>Mono<% } else { %>Optional<% } %><<%= instanceType %>> partialUpdate(<%= instanceType %> <%= instanceName %>);
+
+    /**
+     * Get all the <%= entityInstancePlural %>.
+     *<% if (!paginationNo) { %>
+     * @param pageable the pagination information.<% } %>
+     * @return the list of entities.
+     */
+    <% if (paginationNo) { %><%= listOrFlux %><% } else { %><%= pageOrFlux %><% } %><<%= instanceType %>> findAll(<% if (!paginationNo) { %>Pageable pageable<% } %>);
+
+    <%_ if (jpaMetamodelFiltering && reactive) {  _%>
+      /**
+      * Find <%= entityInstancePlural %> by criteria.
+      *<% if (!paginationNo) { %>
+      * @param pageable the pagination information.<% } %>
+      * @return the list of entities.
+      */
+      <% if (paginationNo) { %><%= listOrFlux %><% } else { %><%= pageOrFlux %><% } %><<%= instanceType %>> findByCriteria(<%= entityClass %>Criteria criteria<% if (!paginationNo) { %>, Pageable pageable<% } %>);
+
+      /**
+      * Find the count of <%= entityInstancePlural %> by criteria.
+      * @param criteria filtering criteria
+      * @return the count of <%= entityInstancePlural %>
+      */
+      public Mono<Long> countByCriteria(<%= entityClass %>Criteria criteria);
+    <%_ } _%>
+
+<%_ for (const relationship of relationships) { _%>
+  <%_ if (relationship.relationshipOneToOne && !relationship.ownerSide) { _%>
+    /**
+     * Get all the <%= restClass %> where <%= relationship.relationshipNameCapitalized %> is {@code null}.
+     *
+     * @return the {@link <%= listOrFlux %>} of entities.
+     */
+    <%= listOrFlux %><<%= instanceType %>> findAllWhere<%= relationship.relationshipNameCapitalized %>IsNull();
+<%_ } } _%>
+
+<%_ if (implementsEagerLoadApis) { _%>
+    /**
+     * Get all the <%= entityInstancePlural %> with eager load of many-to-many relationships.
+     *
+     * @param pageable the pagination information.
+     * @return the list of entities.
+     */
+    <%= pageOrFlux %><<%= instanceType %>> findAllWithEagerRelationships(Pageable pageable);
+
+<%_ } _%>
+<%_ if (reactive) { _%>
+    /**
+    * Returns the number of <%= entityInstancePlural %> available.
+    * @return the number of entities in the database.
+    *
+    */
+    Mono<Long> countAll();
+  <%_ if (searchEngineElasticsearch) { _%>
+
+    /**
+    * Returns the number of <%= entityInstancePlural %> available in search repository.
+    *
+    */
+    Mono<Long> searchCount();
+  <%_  } _%>
+
+<%_  } _%>
+
+    /**
+     * Get the "id" <%= entityInstance %>.
+     *
+     * @param id the id of the entity.
+     * @return the entity.
+     */
+    <%= optionalOrMono %><<%= instanceType %>> findOne(<%= primaryKey.type %> id);
+
+    /**
+     * Delete the "id" <%= entityInstance %>.
+     *
+     * @param id the id of the entity.
+<%_ if (reactive) { _%>
+     * @return a Mono to signal the deletion
+<%_ } _%>
+     */
+    <%- reactive ? 'Mono<Void>' : 'void' %> delete(<%= primaryKey.type %> id);
+<%_ if (searchEngineAny) { _%>
+
+    /**
+     * Search for the <%= entityInstance %> corresponding to the query.
+     *
+     * @param query the query of the search.
+  <%_ if (!paginationNo) { _%>
+     *
+     * @param pageable the pagination information.
+  <%_ } _%>
+     * @return the list of entities.
+     */
+    <% if (!paginationNo) { %><%= pageOrFlux %><<%= instanceType %><% } else { %><%= listOrFlux %><<%= instanceType %><% } %>> search(String query<% if (!paginationNo) { %>, Pageable pageable<% } %>);
+<%_ } _%>
+}

package/dist/generators/server/templates/src/main/java/_package_/_entityPackage_/service/criteria/_entityClass_Criteria.java.ejs

@@ -0,0 +1,167 @@
+package <%= entityAbsolutePackage %>.<%_ if(jpaMetamodelFiltering && reactive) { _%>domain<%_ } else { _%>service<%_ } _%>.criteria;
+
+import java.io.Serializable;
+import java.util.Objects;
+import org.springdoc.core.annotations.ParameterObject;
+import tech.jhipster.service.Criteria;
+<%_ for (const field of fields) { if (field.fieldIsEnum === true) { _%>
+import <%= entityAbsolutePackage %>.domain.enumeration.<%= field.fieldType %>;
+<%_ } } _%>
+import tech.jhipster.service.filter.*;
+
+<%_
+var effectiveRelationships = reactive ? reactiveEagerRelations : relationships;
+var filterVariables = [];
+var extraFilters = {};
+fields.filter(field => !field.transient).forEach((field) => {
+  const fieldType = field.fieldType;
+  if (field.filterableField) {
+    var filterType;
+    if (field.fieldIsEnum) {
+      filterType = fieldType + 'Filter';
+      extraFilters[fieldType] = {type: filterType, superType: 'Filter<' + fieldType + '>', fieldType: fieldType};
+    } else if (field.fieldTypeDuration || field.fieldTypeTemporal || field.fieldTypeCharSequence || field.fieldTypeNumeric || field.fieldTypeBoolean) {
+      filterType = fieldType + 'Filter';
+    } else {
+      filterType = 'Filter<' + fieldType + '>';
+    }
+    filterVariables.push( { filterType : filterType,
+      name: field.fieldName,
+      type: fieldType,
+      fieldInJavaBeanMethod: field.fieldInJavaBeanMethod });
+  }
+});
+effectiveRelationships.forEach((relationship) => {
+const relationshipType = relationship.otherEntity.primaryKey.type;
+const referenceFilterType = '' + relationshipType + 'Filter';
+// user has a String PK when using OAuth, so change relationships accordingly
+let oauthAwareReferenceFilterType = referenceFilterType;
+if (relationship.otherEntityUser && authenticationTypeOauth2) {
+  oauthAwareReferenceFilterType = 'StringFilter';
+}
+filterVariables.push({ filterType : oauthAwareReferenceFilterType,
+  name: relationship.relationshipFieldName + 'Id',
+  type: relationshipType,
+  fieldInJavaBeanMethod: relationship.relationshipNameCapitalized + 'Id' });
+});
+_%>
+/**
+ * Criteria class for the {@link <%= entityAbsoluteClass %>} entity. This class is used
+ * in {@link <%= entityAbsolutePackage %>.web.rest.<%= entityClass %>Resource} to receive all the possible filtering options from
+ * the Http GET request parameters.
+ * For example the following could be a valid request:
+ * {@code /<%= entityApiUrl %>?id.greaterThan=5&attr1.contains=something&attr2.specified=false}
+ * As Spring is unable to properly convert the types, unless specific {@link Filter} class are used, we need to use
+ * fix type specific filters.
+ */
+@ParameterObject
+@SuppressWarnings("common-java:DuplicatedBlocks")
+public class <%= entityClass %>Criteria implements Serializable, Criteria {
+<%_ Object.keys(extraFilters).forEach((key) => {
+  extraFilter = extraFilters[key]; _%>
+    /**
+     * Class for filtering <%= key %>
+     */
+    public static class <%= extraFilter.type %> extends <%- extraFilter.superType %> {
+
+        public <%= extraFilter.type %>() {
+        }
+
+        public <%= extraFilter.type %>(<%= extraFilter.type %> filter) {
+            super(filter);
+        }
+
+        @Override
+        public <%= extraFilter.type %> copy() {
+            return new <%= extraFilter.type %>(this);
+        }
+
+    }
+<%_ }); _%>
+
+    private static final long serialVersionUID = 1L;
+<%_ filterVariables.forEach((filterVariable) => { _%>
+
+    private <%- filterVariable.filterType %> <%= filterVariable.name %>;
+<%_ }); _%>
+
+    private Boolean distinct;
+
+    public <%= entityClass %>Criteria() {
+    }
+
+    public <%= entityClass %>Criteria(<%= entityClass %>Criteria other) {
+<%_ filterVariables.forEach((filterVariable) => { _%>
+        this.<%= filterVariable.name %> = other.<%= filterVariable.name %> == null ? null : other.<%= filterVariable.name %>.copy();
+<%_ }); _%>
+        this.distinct = other.distinct;
+    }
+
+    @Override
+    public <%= entityClass %>Criteria copy() {
+        return new <%= entityClass %>Criteria(this);
+    }
+
+<%_ filterVariables.forEach((filterVariable) => { _%>
+    public <%- filterVariable.filterType %> get<%= filterVariable.fieldInJavaBeanMethod %>() {
+        return <%= filterVariable.name %>;
+    }
+
+    public <%- filterVariable.filterType %> <%= filterVariable.name %>() {
+        if (<%= filterVariable.name %> == null) {
+            <%= filterVariable.name %> = new <%- filterVariable.filterType %>();
+        }
+        return <%= filterVariable.name %>;
+    }
+
+    public void set<%= filterVariable.fieldInJavaBeanMethod %>(<%- filterVariable.filterType %> <%= filterVariable.name %>) {
+        this.<%= filterVariable.name %> = <%= filterVariable.name %>;
+    }
+
+<%_ }); _%>
+
+    public Boolean getDistinct() {
+        return distinct;
+    }
+
+    public void setDistinct(Boolean distinct) {
+        this.distinct = distinct;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        final <%= entityClass %>Criteria that = (<%= entityClass %>Criteria) o;
+        return
+<%_ filterVariables.forEach((filterVariable, index) => { _%>
+            Objects.equals(<%= filterVariable.name %>, that.<%= filterVariable.name %>) &&
+<%_ }); _%>
+            Objects.equals(distinct, that.distinct);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+<%_ filterVariables.forEach((filterVariable, index) => { _%>
+        <%= filterVariable.name %>,
+<%_ }); _%>
+        distinct);
+    }
+
+    // prettier-ignore
+    @Override
+    public String toString() {
+        return "<%= entityClass %>Criteria{" +
+<%_ filterVariables.forEach((field) => { _%>
+            (<%= field.name %> != null ? "<%= field.name %>=" + <%= field.name %> + ", " : "") +
+<%_ }); _%>
+            (distinct != null ? "distinct=" + distinct + ", " : "") +
+            "}";
+    }
+
+}