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

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

@@ -0,0 +1,145 @@
+<%#
+ 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.mapper;
+
+<%_
+  const getOriginalField = field => field.originalField || field;
+  const uuidMapMethod = dtoReferences.some(reference => reference.valueReference && reference.valueReference.field && reference.valueReference.field.fieldTypeUUID);
+  const byteMapMethod = dtoReferences.some(reference => reference.valueReference && reference.valueReference.field && reference.valueReference.field.fieldTypeBytes);
+  const dtoRelationships = dtoReferences.filter(reference => reference.relationship && !reference.relationship.otherEntity.embedded).map(reference => reference.relationship);
+  let otherEntitiesFields = otherEntities
+    .filter(otherEntity => dtoRelationships.some(relationship => relationship.otherEntity === otherEntity))
+    .map(otherEntity =>
+      dtoRelationships
+        .filter(relationship => relationship.otherEntity == otherEntity)
+        .map(({relatedField, collection}) => ({otherEntity, relatedField, collection}))
+    )
+    .flat();
+  otherEntitiesFields.forEach(a => {
+    a.collection = a.collection || otherEntitiesFields.some(b => a.otherEntity === b.otherEntity && getOriginalField(a.relatedField) === getOriginalField(b.relatedField) && b.collection === true)
+  });
+  otherEntitiesFields = this._.uniqWith(otherEntitiesFields, (a, b) => a.otherEntity === b.otherEntity && a.collection === b.collection && getOriginalField(a.relatedField) === getOriginalField(b.relatedField));
+_%>
+
+<%_ if (dtoRelationships.some(r => r.collection)) { _%>
+import java.util.Set;
+import java.util.stream.Collectors;
+<%_ } _%>
+
+import <%= entityAbsoluteClass %>;
+import <%= entityAbsolutePackage %>.service.dto.<%= dtoClass %>;
+
+<%_ for (const otherEntity of this._.uniq(dtoRelationships.map(relationship => relationship.otherEntity).filter(otherEntity => otherEntity.entityClass !== entityClass))) { _%>
+import <%= otherEntity.entityAbsoluteClass %>;
+import <%= otherEntity.entityAbsolutePackage %>.service.dto.<%= otherEntity.dtoClass %>;
+<%_ } _%>
+
+import org.mapstruct.*;
+<%_ if (uuidMapMethod) { _%>
+
+import java.util.Objects;
+import java.util.UUID;
+<%_ } _%>
+
+/**
+ * Mapper for the entity {@link <%= persistClass %>} and its DTO {@link <%= dtoClass %>}.
+ */
+@Mapper(componentModel = "spring")
+public interface <%= entityClass %>Mapper extends EntityMapper<<%= dtoClass %>, <%= persistClass %>> {
+<%_ if (!embedded) { _%>
+  <%_ var renMapAnotEnt = false; //Render Mapping Annotation during Entity to DTO conversion? _%>
+  <%_ for (relationship of dtoRelationships) { _%>
+    <%_
+      renMapAnotEnt = true;
+      let qualifiedByName = relationship.otherEntity.entityInstance + this._.upperFirst(relationship.otherEntityField);
+      qualifiedByName = qualifiedByName + (relationship.collection ? 'Set' : '');
+    _%>
+    @Mapping(target = "<%= relationship.propertyName %>", source = "<%= relationship.propertyName %>", qualifiedByName="<%= qualifiedByName %>")
+  <%_ } _%>
+  <%_ for (const field of fields.filter(field => field.mapstructExpression)) {
+      renMapAnotEnt = true; _%>
+    @Mapping( target = "<%= field.propertyName %>", expression = "<%- field.mapstructExpression %>")
+  <%_ } _%>
+  <%_ if (renMapAnotEnt) { _%>
+    <%= dtoClass %> toDto(<%= persistClass %> s);
+  <%_ } _%>
+
+  <%_ var renMapAnotDto = false;  //Render Mapping Annotation during DTO to Entity conversion? _%>
+  <%_ if(primaryKey.ids.length > 1) { _%>
+    <%_ renMapAnotDto = true; _%>
+    <%_ for (const id of primaryKey.ids) { _%>
+    @Mapping(target = "id.<%= id.name %>", source = "<%= id.nameDotted %>")
+    <%_ } _%>
+  <%_ } _%>
+  <%_ for (relationship of dtoRelationships) { _%>
+    <%_ if (!relationship.ownerSide) { _%>
+      <%_ renMapAnotDto = true; _%>
+    @Mapping(target = "<%= relationship.propertyName %>", ignore = true)
+    <%_ }
+    if (relationship.collection && fluentMethods) {
+      renMapAnotDto = true; _%>
+    @Mapping(target = "remove<%= relationship.relationshipNameCapitalized %>", ignore = true)
+    <%_ } _%>
+  <%_ } _%>
+  <%_ if (renMapAnotDto) { _%>
+    <%= persistClass %> toEntity(<%= dtoClass %> <%= dtoInstance %>);
+  <%_ } _%>
+  <%_ for (const {otherEntity, relatedField, collection} of otherEntitiesFields) { _%>
+    <%_ const mapperName = otherEntity.entityInstance + this._.upperFirst(relatedField.propertyName); _%>
+
+    @Named("<%= mapperName %>")
+    @BeanMapping(ignoreByDefault = true)
+    <%_ for (const field of otherEntity.primaryKey.fields) { _%>
+    @Mapping(target = "<%= field.propertyName %>", source = "<%= field.propertyName %>")
+    <%_ } _%>
+    <%_ if (!relatedField.id) { _%>
+      <%_ if (relatedField.mapstructExpression) { _%>
+    @Mapping(target = "<%= relatedField.propertyName %>", expression = "<%- relatedField.mapstructExpression %>")
+      <%_ } else { _%>
+    @Mapping(target = "<%= relatedField.propertyName %>", source = "<%= relatedField.propertyName %>")
+      <%_ } _%>
+    <%_ } _%>
+      <%_ if (relatedField.mapstructExpression) { _%>
+    <%- otherEntity.dtoClass %> toDto<%= this._.upperFirst(mapperName) %>(<%- otherEntity.persistClass %> s);
+    <%_ } else { _%>
+    <%- otherEntity.dtoClass %> toDto<%= this._.upperFirst(mapperName) %>(<%- otherEntity.persistClass %> <%= otherEntity.persistInstance %>);
+      <%_ } _%>
+    <%_ if (collection) { %>
+      <%_ const collectionMapperName = otherEntity.entityInstance + this._.upperFirst(relatedField.propertyName) + 'Set'; _%>
+
+    @Named("<%= collectionMapperName %>")
+    default Set<<%- otherEntity.dtoClass %>> toDto<%= this._.upperFirst(mapperName) %>Set(Set<<%- otherEntity.persistClass %>> <%= otherEntity.persistInstance %>) {
+        return <%= otherEntity.persistInstance %>.stream().map(this:: toDto<%= this._.upperFirst(mapperName) %>).collect(Collectors.toSet());
+    }
+    <%_ } _%>
+  <%_ } _%>
+  <%_ if (uuidMapMethod) { _%>
+
+    default String map(UUID value) {
+        return Objects.toString(value, null);
+    }
+  <%_ } _%>
+  <%_ if (byteMapMethod) { _%>
+
+    default String map(byte[] value) {
+        return new String(value);
+    }
+  <%_ } _%>
+<%_ } _%>
+}

package/dist/generators/server/templates/src/main/java/_package_/_entityPackage_/web/rest/_entityClass_Resource.java.ejs

@@ -0,0 +1,449 @@
+<%#
+ 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 %>.web.rest;
+
+<%_
+const viaService = !serviceNo;
+_%>
+<%_ if (!dtoMapstruct || serviceNo) { _%>
+import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
+<%_ } _%>
+import <%= entityAbsolutePackage %>.repository.<%= entityClass %>Repository;
+<%_ if (!serviceNo) { _%>
+import <%= entityAbsolutePackage %>.service.<%= entityClass %>Service;
+<%_ } else { _%>
+  <%_ if (isUsingMapsId === true) { _%>
+import <%= entityAbsolutePackage %>.repository.<%= mapsIdAssoc.otherEntityNameCapitalized %>Repository;
+  <%_ } _%>
+  <%_ if (searchEngineElasticsearch) { _%>
+import <%= entityAbsolutePackage %>.repository.search.<%= entityClass %>SearchRepository;
+  <%_ } _%>
+<%_ } _%>
+<%_ if (saveUserSnapshot) { _%>
+import <%= entityAbsolutePackage %>.repository.UserRepository;
+<%_ } _%>
+import <%= packageName %>.web.rest.errors.BadRequestAlertException;
+<%_ if (searchEngineElasticsearch) { _%>
+import <%= packageName %>.web.rest.errors.ElasticsearchExceptionMapper;
+<%_ } _%>
+<%_ if (dtoMapstruct) { _%>
+import <%= entityAbsolutePackage %>.service.dto.<%= dtoClass %>;
+  <%_ if (serviceNo) { _%>
+import <%= entityAbsolutePackage %>.service.mapper.<%= entityClass %>Mapper;
+  <%_ } _%>
+<%_ } _%>
+<%_ if (jpaMetamodelFiltering && !reactive) {  _%>
+import <%= entityAbsolutePackage %>.service.criteria.<%= entityClass %>Criteria;
+import <%= entityAbsolutePackage %>.service.<%= entityClass %>QueryService;
+<%_ } else if (jpaMetamodelFiltering && reactive) { _%>
+import <%= entityAbsolutePackage %>.domain.criteria.<%= entityClass %>Criteria;
+<%_ } _%>
+
+import tech.jhipster.web.util.HeaderUtil;
+<%_ if (!paginationNo) { _%>
+import tech.jhipster.web.util.PaginationUtil;
+<%_ } _%>
+import tech.jhipster.web.util.<% if (reactive) { %>reactive.<% } %>ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+<%_ if (!paginationNo) { _%>
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+  <%_ if (reactive) { _%>
+import org.springframework.data.domain.PageImpl;
+  <%_ } _%>
+import org.springframework.http.HttpHeaders;
+  <%_ if (reactive) { _%>
+import org.springframework.http.server.reactive.ServerHttpRequest;
+  <%_ } _%>
+  <%_ if (reactive) { _%>
+import org.springframework.web.util.UriComponentsBuilder;
+  <%_ } else { _%>
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
+  <%_ } _%>
+<%_ } _%>
+<%_ if (reactive || (!jpaMetamodelFiltering && !paginationNo)) { _%>
+import org.springframework.http.HttpStatus;
+<%_ } _%>
+<%_ if (reactive) { _%>
+import org.springframework.http.MediaType;
+<%_ } _%>
+import org.springframework.http.ResponseEntity;
+<%_ if (databaseTypeSql && !viaService && (!saveUserSnapshot || isUsingMapsId)) { _%>
+import org.springframework.transaction.annotation.Transactional;
+<%_ } _%>
+import org.springframework.web.bind.annotation.*;
+<%_ if (reactive) { _%>
+import org.springframework.web.server.ResponseStatusException;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+<%_ } _%>
+
+<%_ if (anyPropertyHasValidation) { _%>
+import jakarta.validation.Valid;
+<%_ } _%>
+
+<%_ if (anyPropertyHasValidation && !readOnly) { _%>
+import jakarta.validation.constraints.NotNull;
+<%_ } _%>
+import java.net.URI;
+import java.net.URISyntaxException;
+<%_ if (paginationNo && dtoMapstruct && !viaService && fieldsContainNoOwnerOneToOne) { _%>
+import java.util.LinkedList;
+<%_ } _%>
+<%_ if (!paginationNo && reactive) { _%>
+import java.util.ArrayList;
+<%_ } _%>
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+<%_ if (primaryKey.hasUUID) { _%>
+import java.util.UUID;
+<%_ } _%>
+<%_ if ((searchEngineAny || fieldsContainNoOwnerOneToOne) && !reactive) { _%>
+  <%_ if (!viaService) { _%>
+import java.util.stream.Collectors;
+  <%_ } _%>
+  <%_ if (!databaseTypeSql || !reactive) { _%>
+import java.util.stream.StreamSupport;
+  <%_ } _%>
+<%_ } _%>
+
+/**
+ * REST controller for managing {@link <%= entityAbsoluteClass %>}.
+ */
+@RestController
+@RequestMapping("/api")
+<%_ if (databaseTypeSql && !viaService && !saveUserSnapshot) { _%>
+@Transactional
+<%_ } _%>
+public class <%= entityClass %>Resource {
+
+    private final Logger log = LoggerFactory.getLogger(<%= entityClass %>Resource.class);
+<%_ if (!readOnly) { _%>
+
+  <%_ let entityName = entityInstance;
+  if (clientRootFolder && !skipUiGrouping) {
+    entityName = this._.camelCase(`${clientRootFolder}${entityClass}`);
+  } _%>
+    private static final String ENTITY_NAME = "<%= entityName %>";
+
+    @Value("${jhipster.clientApp.name}")
+    private String applicationName;
+<%_ } _%>
+    <%_
+    const instanceType = restClass;
+    const instanceName = restInstance;
+    const mapper = entityInstance  + 'Mapper';
+    const entityToDtoReference = mapper + '::' + 'toDto';
+    _%><%- include('../../_partials_entity_/inject_template', {readOnly: readOnly, viaService: viaService, constructorName: entityClass + 'Resource', queryService: jpaMetamodelFiltering, isUsingMapsId: isUsingMapsId, mapsIdAssoc: mapsIdAssoc, isController: true, reactive: reactive}); -%>
+<%_ if (!readOnly) { _%>
+
+    /**
+     * {@code POST  /<%= entityApiUrl %>} : Create a new <%= entityInstance %>.
+     *
+     * @param <%= instanceName %> the <%= instanceName %> to create.
+     * @return the {@link ResponseEntity} with status {@code 201 (Created)} and with body the new <%= instanceName %>, or with status {@code 400 (Bad Request)} if the <%= entityInstance %> has already an ID.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PostMapping("/<%= entityApiUrl %>")
+    public <% if (reactive) { %>Mono<<% } %>ResponseEntity<<%= instanceType %>><% if (reactive) { %>><% } %> create<%= entityClass %>(<% if (anyPropertyHasValidation) { %>@Valid <% } %>@RequestBody <%= instanceType %> <%= instanceName %>) throws URISyntaxException {
+        log.debug("REST request to save <%= entityClass %> : {}", <%= instanceName %>);
+        if (<%= instanceName %>.get<%= primaryKey.nameCapitalized %>() != null) {
+            throw new BadRequestAlertException("A new <%= entityInstance %> cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+  <%_ if (saveUserSnapshot) { _%>
+    <% for (const userRelationship of relationships.filter(rel => rel.otherEntity.builtInUser)) { %>
+      <%_ if (userRelationship.collection) { _%>
+        if (<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalizedPlural %>() != null) {
+            // Save users in case they are new and only exist in gateway
+            userRepository.saveAll(<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalizedPlural %>());
+        }
+      <%_ } else { _%>
+        if (<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalized %>() != null) {
+            // Save user in case it's new and only exists in gateway
+            userRepository.save(<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalized %>());
+        }
+      <%_ } _%>
+    <% } %>
+  <%_ } _%>
+  <%_ if (!isUsingMapsId) { _%>
+    <%_ for (field of primaryKey.fields.filter(f => f.autoGenerateByService)) { _%>
+        <%= instanceName %>.set<%= field.fieldNameCapitalized %>(UUID.randomUUID());
+    <%_ } _%>
+  <%_ } _%>
+<%- include('/_global_partials_entity_/save_template', {viaService: viaService, returnDirectly: false, isUsingMapsId: isUsingMapsId, mapsIdAssoc: mapsIdAssoc, isController: true}); -%>
+  <%_ if (reactive) { _%>
+            .map(result -> {
+                try {
+                    return ResponseEntity.created(new URI("/api/<%= entityApiUrl %>/" + result.get<%= primaryKey.nameCapitalized %>()))
+                        .headers(HeaderUtil.createEntityCreationAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, result.get<%= primaryKey.nameCapitalized %>()<% if (!primaryKey.typeString) { %>.toString()<% } %>))
+                        .body(result);
+                } catch (URISyntaxException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+  <%_ } else { _%>
+        return ResponseEntity.created(new URI("/api/<%= entityApiUrl %>/" + result.get<%= primaryKey.nameCapitalized %>()))
+            .headers(HeaderUtil.createEntityCreationAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, result.get<%= primaryKey.nameCapitalized %>()<% if (!primaryKey.typeString) { %>.toString()<% } %>))
+            .body(result);
+  <%_ } _%>
+    }
+
+    /**
+     * {@code PUT  /<%= entityApiUrl %>/:<%= primaryKey.name %>} : Updates an existing <%= entityInstance %>.
+     *
+     * @param <%= primaryKey.name %> the id of the <%= instanceName %> to save.
+     * @param <%= instanceName %> the <%= instanceName %> to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated <%= instanceName %>,
+     * or with status {@code 400 (Bad Request)} if the <%= instanceName %> is not valid,
+     * or with status {@code 500 (Internal Server Error)} if the <%= instanceName %> couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PutMapping("/<%= entityApiUrl %>/{<%= primaryKey.name %>}")
+    public <% if (reactive) { %>Mono<<% } %>ResponseEntity<<%= instanceType %>><% if (reactive) { %>><% } %> update<%= entityClass %>(
+        @PathVariable(value = "<%= primaryKey.name %>", required = false) final <%= primaryKey.type %> <%= primaryKey.name %>,
+        <% if (anyPropertyHasValidation) { %>@Valid <% } %>@RequestBody <%= instanceType %> <%= instanceName %>
+    ) throws URISyntaxException {
+        log.debug("REST request to update <%= entityClass %> : {}, {}", <%= primaryKey.name %>, <%= instanceName %>);
+        if (<%= instanceName %>.get<%= primaryKey.nameCapitalized %>() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(<%= primaryKey.name %>, <%= instanceName %>.get<%= primaryKey.nameCapitalized %>())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+  <%_ if (reactive) { _%>
+        return <%= entityInstance %>Repository.existsById(<%= primaryKey.name %>).flatMap(exists -> {
+            if (!exists) {
+                return Mono.error(new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound"));
+            }
+  <%_ } else { _%>
+        if (!<%= entityInstance %>Repository.existsById(<%= primaryKey.name %>)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+  <%_ } _%>
+
+  <%_ if (saveUserSnapshot) { _%>
+    <% for (const userRelationship of relationships.filter(rel => rel.otherEntity.builtInUser)) { %>
+      <%_ if (userRelationship.collection) { _%>
+        if (<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalizedPlural %>() != null) {
+            // Save users in case they are new and only exist in gateway
+            userRepository.saveAll(<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalizedPlural %>());
+        }
+      <%_ } else { _%>
+        if (<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalized %>() != null) {
+            // Save user in case it's new and only exists in gateway
+            userRepository.save(<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalized %>());
+        }
+      <%_ } _%>
+    <% } %>
+  <%_ } _%>
+<%- include('/_global_partials_entity_/update_template', {updatableEntity, viaService: viaService, returnDirectly: false, isUsingMapsId: false, mapsIdAssoc: mapsIdAssoc, isController: true, isPersisted: requiresPersistableImplementation}); -%>
+  <%_ if (reactive) { _%>
+            .switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)))
+            .map(result -> ResponseEntity.ok()
+                .headers(HeaderUtil.createEntityUpdateAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, result.get<%= primaryKey.nameCapitalized %>()<% if (!primaryKey.typeString) { %>.toString()<% } %>))
+                .body(result)
+            );
+        });
+  <%_ } else { _%>
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, <%= instanceName %>.get<%= primaryKey.nameCapitalized %>()<% if (!primaryKey.typeString) { %>.toString()<% } %>))
+            .body(result);
+  <%_ } _%>
+    }
+
+
+    /**
+     * {@code PATCH  /<%= entityApiUrl %>/:<%= primaryKey.name %>} : Partial updates given fields of an existing <%= entityInstance %>, field will ignore if it is null
+     *
+     * @param <%= primaryKey.name %> the id of the <%= instanceName %> to save.
+     * @param <%= instanceName %> the <%= instanceName %> to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated <%= instanceName %>,
+     * or with status {@code 400 (Bad Request)} if the <%= instanceName %> is not valid,
+     * or with status {@code 404 (Not Found)} if the <%= instanceName %> is not found,
+     * or with status {@code 500 (Internal Server Error)} if the <%= instanceName %> couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PatchMapping(value = "/<%= entityApiUrl %>/{<%= primaryKey.name %>}", consumes = {"application/json", "application/merge-patch+json"})
+    public <% if (reactive) { %>Mono<<% } %>ResponseEntity<<%= instanceType %>><% if (reactive) { %>><% } %> partialUpdate<%= entityClass %>(
+    @PathVariable(value = "<%= primaryKey.name %>", required = false) final <%= primaryKey.type %> <%= primaryKey.name %>,
+    <% if (anyPropertyHasValidation) { %>@NotNull <% } %>@RequestBody <%= instanceType %> <%= instanceName %>) throws URISyntaxException {
+        log.debug("REST request to partial update <%= entityClass %> partially : {}, {}", <%= primaryKey.name %>, <%= instanceName %>);
+        if (<%= instanceName %>.get<%= primaryKey.nameCapitalized %>() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(<%= primaryKey.name %>, <%= instanceName %>.get<%= primaryKey.nameCapitalized %>())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+  <%_ if (reactive) { _%>
+        return <%= entityInstance %>Repository.existsById(<%= primaryKey.name %>).flatMap(exists -> {
+            if (!exists) {
+                return Mono.error(new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound"));
+            }
+  <%_ } else { _%>
+        if (!<%= entityInstance %>Repository.existsById(<%= primaryKey.name %>)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+  <%_ } _%>
+
+  <%_ if (saveUserSnapshot) { _%>
+    <% for (const userRelationship of relationships.filter(rel => rel.otherEntity.builtInUser)) { %>
+      <%_ if (userRelationship.collection) { _%>
+        if (<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalizedPlural %>() != null) {
+            // Save users in case they are new and only exist in gateway
+            userRepository.saveAll(<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalizedPlural %>());
+        }
+      <%_ } else { _%>
+        if (<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalized %>() != null) {
+            // Save user in case it's new and only exists in gateway
+            userRepository.save(<%= instanceName %>.get<%= userRelationship.relationshipNameCapitalized %>());
+        }
+      <%_ } _%>
+    <% } %>
+  <%_ } _%>
+
+            <%- include('../../_partials_entity_/patch_template', {isService: false, viaService: viaService}); -%>
+  <%_ if (reactive) { _%>
+            return result
+                .switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)))
+                .map(res -> ResponseEntity.ok()
+                .headers(HeaderUtil.createEntityUpdateAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, res.get<%= primaryKey.nameCapitalized %>()<% if (primaryKey.type !== 'String') { %>.toString()<% } %>))
+                .body(res)
+            );
+        });
+  <%_ } else { _%>
+            return ResponseUtil.wrapOrNotFound(
+                result,
+                HeaderUtil.createEntityUpdateAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, <%= instanceName %>.get<%= primaryKey.nameCapitalized %>()<% if (primaryKey.type !== 'String') { %>.toString()<% } %>)
+            );
+  <%_ } _%>
+    }
+<%_ } _%>
+
+    /**
+     * {@code GET  /<%= entityApiUrl %>} : get all the <%= entityInstancePlural %>.
+     *
+<%_ if (!paginationNo) { _%>
+     * @param pageable the pagination information.
+  <%_ if (reactive) { _%>
+     * @param request a {@link ServerHttpRequest} request.
+  <%_ } _%>
+<%_ } _%>
+<%_ if (!jpaMetamodelFiltering && implementsEagerLoadApis) { _%>
+     * @param eagerload flag to eager load entities from relationships (This is applicable for many-to-many).
+<%_ } _%>
+<%_ if (jpaMetamodelFiltering) { _%>
+     * @param criteria the criteria which the requested entities should match.
+<%_ } else if (fieldsContainNoOwnerOneToOne) { _%>
+     * @param filter the filter of the request.
+<%_ } _%>
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and the list of <%= entityInstancePlural %> in body.
+     */
+<%_ if (reactive) { _%>
+    @GetMapping(value = "/<%= entityApiUrl %>", produces = MediaType.APPLICATION_JSON_VALUE)
+<%_ } else { _%>
+    @GetMapping("/<%= entityApiUrl %>")
+<%_ } _%>
+<%_ if (databaseTypeSql && isUsingMapsId && !viaService) { _%>
+    @Transactional(readOnly = true)
+<%_ } _%>
+<%- include('../../_partials_entity_/get_all_template', {viaService}); -%>
+
+<%_ if (!jpaMetamodelFiltering && reactive && paginationNo) { _%>
+    /**
+     * {@code GET  /<%= entityApiUrl %>} : get all the <%= entityInstancePlural %> as a stream.
+     * @return the {@link Flux} of <%= entityInstancePlural %>.
+     */
+    @GetMapping(value = "/<%= entityApiUrl %>", produces = MediaType.APPLICATION_NDJSON_VALUE)
+  <%_ if (databaseTypeSql && isUsingMapsId && !viaService) { _%>
+    @Transactional(readOnly = true)
+  <%_ } _%>
+    public Flux<<%= instanceType %>> getAll<%= entityClassPlural %>AsStream() {
+        log.debug("REST request to get all <%= entityClassPlural %> as a stream");
+  <%_ if (viaService) { _%>
+        return <%= entityInstance %>Service.findAll();
+  <%_ } else { _%>
+        return <%= entityInstance %>Repository.findAll()<%_ if (dtoMapstruct) { _%>.map(<%= entityToDtoReference %>)<%_ } _%>;
+  <%_ } _%>
+    }
+
+<%_ } _%>
+    /**
+     * {@code GET  /<%= entityApiUrl %>/:id} : get the "id" <%= entityInstance %>.
+     *
+     * @param id the id of the <%= instanceName %> to retrieve.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the <%= instanceName %>, or with status {@code 404 (Not Found)}.
+     */
+    @GetMapping("/<%= entityApiUrl %>/{id}")
+<%_ if (databaseTypeSql && isUsingMapsId && !viaService) { _%>
+    @Transactional(readOnly = true)
+<%_ } _%>
+    public <% if (reactive) { %>Mono<<% } %>ResponseEntity<<%= instanceType %>><% if (reactive) { %>><% } %> get<%= entityClass %>(@PathVariable <%= primaryKey.type %> id) {
+        log.debug("REST request to get <%= entityClass %> : {}", id);<%- include('../../_partials_entity_/get_template', {viaService, returnDirectly:false, implementsEagerLoadApis}); -%>
+        return ResponseUtil.wrapOrNotFound(<%= instanceName %>);
+    }
+<%_ if (!readOnly) { _%>
+
+    /**
+     * {@code DELETE  /<%= entityApiUrl %>/:id} : delete the "id" <%= entityInstance %>.
+     *
+     * @param id the id of the <%= instanceName %> to delete.
+     * @return the {@link ResponseEntity} with status {@code 204 (NO_CONTENT)}.
+     */
+    @DeleteMapping("/<%= entityApiUrl %>/{id}")
+    public <% if (reactive) { %>Mono<<% } %>ResponseEntity<Void><% if (reactive) { %>><% } %> delete<%= entityClass %>(@PathVariable <%= primaryKey.type %> id) {
+        log.debug("REST request to delete <%= entityClass %> : {}", id);
+<%- include('../../_partials_entity_/delete_template', {viaService: viaService, fromResource: true}); -%>
+  <%_ if (reactive) { _%>
+    <%_ if (databaseTypeCouchbase) { _%>
+            .then(Mono.just(ResponseEntity.noContent()
+                .headers(HeaderUtil.createEntityDeletionAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, id<% if (primaryKey.type !== 'String') { %>.toString()<% } %>)).build())
+            );
+    <%_ } else { %>
+            .then(Mono.just(ResponseEntity.noContent()
+                .headers(HeaderUtil.createEntityDeletionAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, id<% if (primaryKey.type !== 'String') { %>.toString()<% } %>)).build())
+        );
+    <%_ } _%>
+  <%_ } else { _%>
+        return ResponseEntity.noContent().headers(HeaderUtil.createEntityDeletionAlert(applicationName, <%= enableTranslation %>, ENTITY_NAME, id<% if (!primaryKey.fields[0].fieldTypeString) { %>.toString()<% } %>)).build();
+  <%_ } _%>
+    }
+<%_ } _%>
+<%_ if (searchEngineAny) { _%>
+
+    /**
+     * {@code SEARCH  /_search/<%= entityApiUrl %>?query=:query} : search for the <%= entityInstance %> corresponding
+     * to the query.
+     *
+     * @param query the query of the <%= entityInstance %> search.
+  <%_ if (!paginationNo) { _%>
+     * @param pageable the pagination information.
+    <%_ if (reactive) { _%>
+     * @param request a {@link ServerHttpRequest} request.
+    <%_ } _%>
+  <%_ } _%>
+     * @return the result of the search.
+     */
+    @GetMapping("/_search/<%= entityApiUrl %>")<%- include('../../_partials_entity_/search_template', {viaService}); -%>
+<%_ } _%>
+}