generator-jhipster 7.8.0 → 7.9.1

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/service/entity.service.ts.ejs

@@ -39,8 +39,27 @@ import { createRequestOption } from 'app/core/request/request-util';
 <%_ if (searchEngine) { _%>
 import { <%= searchType %> } from 'app/core/request/request.model';
 <%_ } _%>
-import { I<%= entityAngularName %>, get<%= entityAngularName %>Identifier } from '../<%= entityFileName %>.model';
+import { I<%= entityAngularName %>, New<%= entityAngularName %> } from '../<%= entityFileName %>.model';
 
+export type PartialUpdate<%= entityAngularName %> = Partial<I<%= entityAngularName %>> & Pick<I<%= entityAngularName %>, '<%= primaryKey.name %>'>;
+
+<%_ const entityRestName = fieldsContainDate ? `Rest${entityAngularName}` : `I${entityAngularName}`; _%>
+<%_ if (fieldsContainDate) { _%>
+type RestOf<T extends I<%= entityAngularName %> | New<%= entityAngularName %>> =
+  Omit<T, '<%- fields.filter(field => field.fieldTypeTemporal).map(field => field.fieldName).join("' | '") %>'> &
+  {
+  <%_ for (const field of fields.filter(field => field.fieldTypeTemporal)) { _%>
+  <%= field.fieldName %>?: string | null;
+  <%_ } _%>
+  };
+
+export type <%= entityRestName %> = RestOf<I<%= entityAngularName %>>;
+
+export type New<%= entityRestName %> = RestOf<New<%= entityAngularName %>>;
+
+export type PartialUpdate<%= entityRestName %> = RestOf<PartialUpdate<%= entityAngularName %>>;
+
+<%_ } _%>
 export type EntityResponseType = HttpResponse<I<%= entityAngularName %>>;
 export type EntityArrayResponseType = HttpResponse<I<%= entityAngularName %>[]>;
 
@@ -54,46 +73,46 @@ export class <%= entityAngularName %>Service {
     constructor(protected http: HttpClient, protected applicationConfigService: ApplicationConfigService) {}
 
 <%_ if (!readOnly) { _%>
-    create(<%= entityInstance %>: I<%= entityAngularName %>): Observable<EntityResponseType> {
+    create(<%= entityInstance %>: New<%= entityAngularName %>): Observable<EntityResponseType> {
     <%_ if (fieldsContainDate) { _%>
         const copy = this.convertDateFromClient(<%= entityInstance %>);
     <%_ } _%>
-        return this.http.post<I<%= entityAngularName %>>(this.resourceUrl,
+        return this.http.post<<%= entityRestName %>>(this.resourceUrl,
                 <% if (fieldsContainDate) { %> copy <% } else { %> <%= entityInstance %> <% } %>,
                 { observe: 'response' })
-        <% if (fieldsContainDate) { %>.pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)))<% } %>;
+        <% if (fieldsContainDate) { %>.pipe(map(res => this.convertResponseFromServer(res)))<% } %>;
     }
 
     update(<%= entityInstance %>: I<%= entityAngularName %>): Observable<EntityResponseType> {
     <%_ if (fieldsContainDate) { _%>
         const copy = this.convertDateFromClient(<%= entityInstance %>);
     <%_ } _%>
-        return this.http.put<I<%= entityAngularName %>>(`${this.resourceUrl}/${get<%= entityAngularName %>Identifier(<%= entityInstance %>) as <%= primaryKey.tsType %>}`,
+        return this.http.put<<%= entityRestName %>>(`${this.resourceUrl}/${this.get<%= entityAngularName %>Identifier(<%= entityInstance %>)}`,
                 <% if (fieldsContainDate) { %> copy <% } else { %> <%= entityInstance %> <% } %>,
                 { observe: 'response' })
-        <% if (fieldsContainDate) { %>.pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)))<% } %>;
+        <% if (fieldsContainDate) { %>.pipe(map(res => this.convertResponseFromServer(res)))<% } %>;
     }
 
-    partialUpdate(<%= entityInstance %>: I<%= entityAngularName %>): Observable<EntityResponseType> {
+    partialUpdate(<%= entityInstance %>: PartialUpdate<%= entityAngularName %>): Observable<EntityResponseType> {
     <%_ if (fieldsContainDate) { _%>
         const copy = this.convertDateFromClient(<%= entityInstance %>);
     <%_ } _%>
-        return this.http.patch<I<%= entityAngularName %>>(`${this.resourceUrl}/${get<%= entityAngularName %>Identifier(<%= entityInstance %>) as <%= primaryKey.tsType %>}`,
+        return this.http.patch<<%= entityRestName %>>(`${this.resourceUrl}/${this.get<%= entityAngularName %>Identifier(<%= entityInstance %>)}`,
                 <% if (fieldsContainDate) { %> copy <% } else { %> <%= entityInstance %> <% } %>,
                 { observe: 'response' })
-        <% if (fieldsContainDate) { %>.pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)))<% } %>;
+        <% if (fieldsContainDate) { %>.pipe(map(res => this.convertResponseFromServer(res)))<% } %>;
     }
 <%_ } _%>
 
     find(id: <%= tsKeyType %>): Observable<EntityResponseType> {
-        return this.http.get<I<%= entityAngularName %>>(`${this.resourceUrl}/${id}`, { observe: 'response' })
-            <% if (fieldsContainDate) { %>.pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)))<% } %>;
+        return this.http.get<<%= entityRestName %>>(`${this.resourceUrl}/${id}`, { observe: 'response' })
+            <% if (fieldsContainDate) { %>.pipe(map(res => this.convertResponseFromServer(res)))<% } %>;
     }
 
     query(req?: any): Observable<EntityArrayResponseType> {
         const options = createRequestOption(req);
-        return this.http.get<I<%= entityAngularName %>[]>(this.resourceUrl, { params: options, observe: 'response' })
-            <% if (fieldsContainDate) { %>.pipe(map((res: EntityArrayResponseType) => this.convertDateArrayFromServer(res)))<% } %>;
+        return this.http.get<<%= entityRestName %>[]>(this.resourceUrl, { params: options, observe: 'response' })
+            <% if (fieldsContainDate) { %>.pipe(map(res => this.convertResponseArrayFromServer(res)))<% } %>;
     }
 
 <%_ if (!readOnly) { _%>
@@ -105,18 +124,26 @@ export class <%= entityAngularName %>Service {
 <%_ if (searchEngine) { _%>
     search(req: <%= searchType %>): Observable<EntityArrayResponseType> {
         const options = createRequestOption(req);
-        return this.http.get<I<%= entityAngularName %>[]>(this.resourceSearchUrl, { params: options, observe: 'response' })
-            <% if (fieldsContainDate) { %>.pipe(map((res: EntityArrayResponseType) => this.convertDateArrayFromServer(res)))<% } %>;
+        return this.http.get<<%= entityRestName %>[]>(this.resourceSearchUrl, { params: options, observe: 'response' })
+            <% if (fieldsContainDate) { %>.pipe(map(res => this.convertResponseArrayFromServer(res)))<% } %>;
     }
 <%_ } _%>
 
-    add<%= entityAngularName %>ToCollectionIfMissing(<%= entityInstance %>Collection: I<%= entityAngularName %>[], ...<%= entityInstancePlural %>ToCheck: (I<%= entityAngularName %> | null | undefined)[]): I<%= entityAngularName %>[] {
-        const <%= entityInstancePlural %>: I<%= entityAngularName %>[] = <%= entityInstancePlural %>ToCheck.filter(isPresent);
+    get<%= entityAngularName %>Identifier(<%= entityInstance %>: Pick<I<%= entityAngularName %>, '<%= primaryKey.name %>'>): <%= primaryKey.tsType %> {
+        return <%= entityInstance %>.<%= primaryKey.name %>;
+    }
+
+    compare<%= entityAngularName %>(o1: Pick<I<%= entityAngularName %>, '<%= primaryKey.name %>'> | null, o2: Pick<I<%= entityAngularName %>, '<%= primaryKey.name %>'> | null): boolean {
+        return o1 && o2 ? this.get<%= entityAngularName %>Identifier(o1) === this.get<%= entityAngularName %>Identifier(o2) : o1 === o2;
+    }
+
+    add<%= entityAngularName %>ToCollectionIfMissing<Type extends Pick<I<%= entityAngularName %>, '<%= primaryKey.name %>'>>(<%= entityInstance %>Collection: Type[], ...<%= entityInstancePlural %>ToCheck: (Type | null | undefined)[]): Type[] {
+        const <%= entityInstancePlural %>: Type[] = <%= entityInstancePlural %>ToCheck.filter(isPresent);
         if (<%= entityInstancePlural %>.length > 0) {
-            const <%= entityInstance %>CollectionIdentifiers = <%= entityInstance %>Collection.map(<%= entityInstance %>Item => get<%= entityAngularName %>Identifier(<%= entityInstance %>Item)!);
+            const <%= entityInstance %>CollectionIdentifiers = <%= entityInstance %>Collection.map(<%= entityInstance %>Item => this.get<%= entityAngularName %>Identifier(<%= entityInstance %>Item)!);
             const <%= entityInstancePlural %>ToAdd = <%= entityInstancePlural %>.filter(<%= entityInstance %>Item => {
-                const <%= entityInstance %>Identifier = get<%= entityAngularName %>Identifier(<%= entityInstance %>Item);
-                if (<%= entityInstance %>Identifier == null || <%= entityInstance %>CollectionIdentifiers.includes(<%= entityInstance %>Identifier)) {
+                const <%= entityInstance %>Identifier = this.get<%= entityAngularName %>Identifier(<%= entityInstance %>Item);
+                if (<%= entityInstance %>CollectionIdentifiers.includes(<%= entityInstance %>Identifier)) {
                     return false;
                 }
                 <%= entityInstance %>CollectionIdentifiers.push(<%= entityInstance %>Identifier);
@@ -128,41 +155,39 @@ export class <%= entityAngularName %>Service {
     }
 
 <%_ if (fieldsContainDate) { _%>
-    protected convertDateFromClient(<%= entityInstance %>: I<%= entityAngularName %>): I<%= entityAngularName %> {
-        return Object.assign({}, <%= entityInstance %>, {
+    protected convertDateFromClient<T extends I<%= entityAngularName %> | New<%= entityAngularName %> | PartialUpdate<%= entityAngularName %>>(<%= entityInstance %>: T): RestOf<T> {
+        return {
+            ...<%= entityInstance %>,
     <%_ for (const field of fields) { _%>
         <%_ if (field.fieldTypeTimed) { _%>
-        <%= field.fieldName %>: <%= entityInstance %>.<%= field.fieldName %>?.isValid() ? <%= entityInstance %>.<%= field.fieldName %>.toJSON() : undefined,
+        <%= field.fieldName %>: <%= entityInstance %>.<%= field.fieldName %>?.toJSON() ?? null,
         <%_ } _%>
         <%_ if (field.fieldTypeLocalDate) { _%>
-        <%= field.fieldName %>: <%= entityInstance %>.<%= field.fieldName %>?.isValid() ? <%= entityInstance %>.<%= field.fieldName %>.format(DATE_FORMAT) : undefined,
+        <%= field.fieldName %>: <%= entityInstance %>.<%= field.fieldName %>?.format(DATE_FORMAT) ?? null,
         <%_ } _%>
     <%_ } _%>
-        });
+        };
     }
 
-    protected convertDateFromServer(res: EntityResponseType): EntityResponseType {
-        if (res.body) {
-    <%_ for (const field of fields) { _%>
-        <%_ if (field.fieldTypeTemporal) { _%>
-            res.body.<%= field.fieldName %> = res.body.<%= field.fieldName %> ? dayjs(res.body.<%= field.fieldName %>) : undefined;
-        <%_ } _%>
+    protected convertDateFromServer(rest<%= entityAngularName %>: <%= entityRestName %>): I<%= entityAngularName %> {
+        return {
+            ...rest<%= entityAngularName %>,
+    <%_ for (const field of fields.filter(field => field.fieldTypeTemporal)) { _%>
+            <%= field.fieldName %>: rest<%= entityAngularName %>.<%= field.fieldName %> ? dayjs(rest<%= entityAngularName %>.<%= field.fieldName %>) : undefined,
     <%_ } _%>
         }
-        return res;
     }
 
-    protected convertDateArrayFromServer(res: EntityArrayResponseType): EntityArrayResponseType {
-        if (res.body) {
-            res.body.forEach ((<%= entityInstance %>: I<%= entityAngularName %>) => {
-    <%_ for (const field of fields) { _%>
-        <%_ if (field.fieldTypeTemporal) { _%>
-                <%= entityInstance %>.<%= field.fieldName %> = <%= entityInstance %>.<%= field.fieldName %> ? dayjs(<%= entityInstance %>.<%= field.fieldName %>) : undefined;
-        <%_ } _%>
-    <%_ } _%>
-            });
-        }
-        return res;
-    }
+  protected convertResponseFromServer(res: HttpResponse<<%= entityRestName %>>): HttpResponse<I<%= entityAngularName %>> {
+    return res.clone({
+      body: res.body ? this.convertDateFromServer(res.body) : null,
+    });
+  }
+
+  protected convertResponseArrayFromServer(res: HttpResponse<<%= entityRestName %>[]>): HttpResponse<I<%= entityAngularName %>[]> {
+    return res.clone({
+      body: res.body ? res.body.map(item => this.convertDateFromServer(item)) : null,
+    });
+  }
 <%_ } _%>
 }

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/update/entity-form.service.spec.ts.ejs

@@ -0,0 +1,111 @@
+<%#
+ Copyright 2013-2022 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.
+-%>
+import { TestBed } from '@angular/core/testing';
+
+import { sampleWithRequiredData, sampleWithNewData } from '../<%= entityFileName %>.test-samples';
+
+import { <%= entityAngularName %>FormService } from './<%= entityFileName %>-form.service';
+
+describe('<%= entityAngularName %> Form Service', () => {
+  let service: <%= entityAngularName %>FormService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(<%= entityAngularName %>FormService);
+  });
+
+  describe('Service methods', () => {
+    describe('create<%= entityAngularName %>FormGroup', () => {
+      it('should create a new form with FormControl', () => {
+        const formGroup = service.create<%= entityAngularName %>FormGroup();
+
+        expect(formGroup.controls).toEqual(
+          expect.objectContaining({
+<%_ for (const field of fields) { _%>
+            <%= field.fieldName %>: expect.any(Object),
+<%_ } _%>
+<%_ for (const relationship of relationships.filter(relationship => relationship.ownerSide || relationship.relationshipManyToMany)) { _%>
+            <%= relationship.propertyName %>: expect.any(Object),
+<%_ } _%>
+          })
+        );
+      });
+
+      it('passing I<%= entityAngularName %> should create a new form with FormGroup', () => {
+        const formGroup = service.create<%= entityAngularName %>FormGroup(sampleWithRequiredData);
+
+        expect(formGroup.controls).toEqual(expect.objectContaining({
+<%_ for (const field of fields) { _%>
+          <%= field.fieldName %>: expect.any(Object),
+<%_ } _%>
+<%_ for (const relationship of relationships.filter(relationship => relationship.ownerSide || relationship.relationshipManyToMany)) { _%>
+          <%= relationship.propertyName %>: expect.any(Object),
+<%_ } _%>
+        }));
+      });
+    });
+
+    describe('get<%= entityAngularName %>', () => {
+      it('should return New<%= entityAngularName %> for default <%= entityAngularName %> initial value', () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const formGroup = service.create<%= entityAngularName %>FormGroup(sampleWithNewData);
+
+        const <%= entityInstance %> = service.get<%= entityAngularName %>(formGroup) as any;
+
+        expect(<%= entityInstance %>).toMatchObject(sampleWithNewData);
+      });
+
+      it('should return New<%= entityAngularName %> for empty <%= entityAngularName %> initial value', () => {
+        const formGroup = service.create<%= entityAngularName %>FormGroup();
+
+        const <%= entityInstance %> = service.get<%= entityAngularName %>(formGroup) as any;
+
+        expect(<%= entityInstance %>).toMatchObject({});
+      });
+
+      it('should return I<%= entityAngularName %>', () => {
+        const formGroup = service.create<%= entityAngularName %>FormGroup(sampleWithRequiredData);
+
+        const <%= entityInstance %> = service.get<%= entityAngularName %>(formGroup) as any;
+
+        expect(<%= entityInstance %>).toMatchObject(sampleWithRequiredData);
+      });
+    });
+
+    describe('resetForm', () => {
+      it('passing I<%= entityAngularName %> should not enable <%= primaryKey.name %> FormControl', () => {
+        const formGroup = service.create<%= entityAngularName %>FormGroup();
+        expect(formGroup.controls.<%= primaryKey.name %>.disabled).toBe(true);
+
+        service.resetForm(formGroup, sampleWithRequiredData);
+
+        expect(formGroup.controls.<%= primaryKey.name %>.disabled).toBe(true);
+      });
+
+      it('passing New<%= entityAngularName %> should disable <%= primaryKey.name %> FormControl', () => {
+        const formGroup = service.create<%= entityAngularName %>FormGroup(sampleWithRequiredData);
+        expect(formGroup.controls.<%= primaryKey.name %>.disabled).toBe(true);
+
+        service.resetForm(formGroup, { <%= primaryKey.name %>: null });
+
+        expect(formGroup.controls.<%= primaryKey.name %>.disabled).toBe(true);
+      });
+    });
+  });
+});

package/generators/entity-client/templates/angular/src/main/webapp/app/entities/update/entity-form.service.ts.ejs

@@ -0,0 +1,263 @@
+<%#
+ Copyright 2013-2022 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.
+-%>
+<%_
+  const formDefaultProperties = [
+    ...fields.filter(field => field.fieldTypeTimed || field.fieldTypeBoolean || field.id).map(field => field.fieldName),
+    ...relationships.filter(relationship => relationship.collection && (relationship.relationshipManyToMany || relationship.ownerSide)).map(relationship => relationship.propertyName)
+  ];
+  const containDefaultProperties = formDefaultProperties.length > 0;
+  const entityFormName = fieldsContainTimed ? `${entityAngularName}FormRawValue` : `I${entityAngularName}`;
+  const newEntityFormName = fieldsContainTimed ? `New${entityAngularName}FormRawValue` : `New${entityAngularName}`;
+  const noPropertyEntity = fields.filter(field => !field.id).length === 0 && relationships.filter(relationship => relationship.ownerSide || relationship.relationshipManyToMany).length === 0;
+_%>
+import { Injectable } from '@angular/core';
+import { FormGroup, FormControl, Validators } from '@angular/forms';
+
+<%_ if (fields.some(field => field.fieldTypeTimed)) { _%>
+import dayjs from 'dayjs/esm';
+import { DATE_TIME_FORMAT } from 'app/config/input.constants';
+<%_ } _%>
+import { I<%= entityAngularName %>, New<%= entityAngularName %> } from '../<%= entityFileName %>.model';
+
+/**
+ * A partial Type with required key is used as form input.
+ */
+type PartialWithRequiredKeyOf<T extends { <%= primaryKey.name %>: unknown }> = Partial<Omit<T, '<%= primaryKey.name %>'>> & { <%= primaryKey.name %>: T['<%= primaryKey.name %>'] };
+
+/**
+ * Type for createFormGroup and resetForm argument.
+ * It accepts I<%= entityAngularName %> for edit and New<%= entityAngularName %>FormGroupInput for create.
+ */
+type <%= entityAngularName %>FormGroupInput = I<%= entityAngularName %> | PartialWithRequiredKeyOf<New<%= entityAngularName %>>;
+<%_ if (fieldsContainTimed) { _%>
+
+/**
+ * Type that converts some properties for forms.
+ */
+type FormValueOf<T extends I<%= entityAngularName %> | New<%= entityAngularName %>> = Omit<T, '<%- fields.filter(field => field.fieldTypeTimed).map(field => field.fieldName).join("' | '") %>'> & {
+  <%_ for (const field of fields.filter(field => field.fieldTypeTimed)) { _%>
+  <%= field.fieldName %>?: string | null;
+  <%_ } _%>
+};
+
+type <%= entityAngularName %>FormRawValue =  FormValueOf<I<%= entityAngularName %>>;
+
+type New<%= entityAngularName %>FormRawValue =  FormValueOf<New<%= entityAngularName %>>;
+<%_ } _%>
+<%_ if (containDefaultProperties) { _%>
+
+type <%= entityAngularName %>FormDefaults = Pick<New<%= entityAngularName %>, '<%- formDefaultProperties.join("' | '") %>'>;
+<%_ } _%>
+
+type <%= entityAngularName %>FormGroupContent = {
+<%_ for (field of fields) {
+      const { fieldName, fieldType, fieldTypeBlobContent, fieldValidationRequired, tsType, fieldIsEnum } = field;
+_%>
+  <%= fieldName %>: FormControl<<%= entityFormName %>['<%= fieldName %>']<% if (field.id) { %> | New<%= entityAngularName %>['<%= fieldName %>']<% } %>>;
+  <%_ if (field.fieldTypeBinary && !field.blobContentTypeText) { _%>
+  <%= fieldName %>ContentType: FormControl<<%= entityFormName %>['<%= fieldName %>ContentType']>;
+  <%_ } _%>
+<%_ } _%>
+<%_ for (const relationship of relationships.filter(relationship => relationship.ownerSide || relationship.relationshipManyToMany)) {
+      const { propertyName, otherEntity } = relationship;
+_%>
+  <%= propertyName %>: FormControl<<%= entityFormName %>['<%= propertyName %>']>;
+<%_ } _%>
+};
+
+export type <%= entityAngularName %>FormGroup = FormGroup<<%= entityAngularName %>FormGroupContent>;
+
+@Injectable({ providedIn: 'root' })
+export class <%= entityAngularName %>FormService {
+  create<%= entityAngularName %>FormGroup(<%= entityInstance %>: <%= entityAngularName %>FormGroupInput = { <%= primaryKey.name %>: null }): <%= entityAngularName %>FormGroup {
+    const <%= entityInstance %>RawValue =
+<%_ if (fieldsContainTimed) { _%>
+      this.convert<%= entityAngularName %>To<%= entityAngularName %>RawValue(
+<%_ } _%>
+<%_ if (containDefaultProperties) { _%>
+        {
+          ...this.getFormDefaults(),
+          ...<%= entityInstance %>,
+        }
+<%_ } else { _%>
+        <%= entityInstance %>
+<%_ } _%>
+<%_ if (fieldsContainTimed) { _%>
+      )
+<%_ } _%>
+    ;
+
+    return new FormGroup<<%= entityAngularName %>FormGroupContent>({
+<%_ for (const field of fields) {
+      const { fieldName, fieldType, fieldTypeBlobContent, fieldValidateRules, fieldTypeTemporal, fieldValidationRequired, fieldValidationMinLength, fieldValidationMaxLength, fieldValidationMin, fieldValidationMax, fieldValidationPattern } = field;
+      const usesValidators = fieldValidationRequired || fieldValidationMinLength || fieldValidationMaxLength || fieldValidationMin || fieldValidationMax || fieldValidationPattern || field.id;
+_%>
+      <%= fieldName %>: new FormControl(
+  <%_ if (field.id) { _%>
+        { value: <%= entityInstance %>RawValue.<%= fieldName %>, disabled: <% if (field.autoGenerate) { %>true<% } else { %><%= entityInstance %>RawValue.<%= fieldName %> !== null<% } %> },
+  <%_ } else { _%>
+        <%= entityInstance %>RawValue.<%= fieldName %>,
+  <%_ } _%>
+  <%_ if (usesValidators) { _%>
+        {
+    <%_ if (field.id) { _%>
+          nonNullable: true,
+    <%_ } _%>
+          validators: [
+    <%_ if (field.fieldValidationRequired || field.id) { _%>
+            Validators.required,
+    <%_ } _%>
+    <%_ if (field.fieldValidationMinLength) { _%>
+            Validators.minLength(<%= field.fieldValidateRulesMinlength %>),
+    <%_ } _%>
+    <%_ if (field.fieldValidationMaxLength) { _%>
+            Validators.maxLength(<%= field.fieldValidateRulesMaxlength %>),
+    <%_ } _%>
+    <%_ if (field.fieldValidationMin) { _%>
+            Validators.min(<%= field.fieldValidateRulesMin %>),
+    <%_ } _%>
+    <%_ if (field.fieldValidationMax) { _%>
+            Validators.max(<%= field.fieldValidateRulesMax %>),
+    <%_ } _%>
+    <%_ if (field.fieldValidationPattern) { _%>
+            Validators.pattern('<%= field.fieldValidateRulesPattern.replace(/\\/g, '\\\\') %>'),
+    <%_ } _%>
+          ],
+        }
+  <%_ } _%>
+      ),
+  <%_ if (field.fieldTypeBinary && !field.blobContentTypeText) { _%>
+      <%= fieldName %>ContentType: new FormControl(<%= entityInstance %>RawValue.<%= fieldName %>ContentType),
+  <%_ } _%>
+<%_ } _%>
+<%_ for (const relationship of relationships.filter(relationship => relationship.ownerSide || relationship.relationshipManyToMany)) {
+      const { relationshipRequired, propertyName, relationshipName, collection, otherEntity } = relationship;
+_%>
+      <%= propertyName %>: new FormControl(
+        <%= entityInstance %>RawValue.<%= propertyName %><% if (collection) { %> ?? []<% } %>
+  <%_ if (!collection && relationshipRequired) { _%>
+        , {
+          validators: [Validators.required],
+        }
+  <%_ } _%>
+      ),
+<%_ } _%>
+    });
+  }
+
+  get<%= entityAngularName %>(form: <%= entityAngularName %>FormGroup): I<%= entityAngularName %> | New<%= entityAngularName %> {
+<%_ if (noPropertyEntity) { _%>
+    if (form.controls.<%= primaryKey.name %>.disabled) {
+      // form.value returns <%= primaryKey.name %> with null value for FormGroup with only one FormControl
+      return {};
+    }
+<%_ } _%>
+<%_ if (fieldsContainTimed) { _%>
+    return this.convert<%= entityAngularName %>RawValueTo<%= entityAngularName %>(form.getRawValue() as <%= entityAngularName %>FormRawValue | New<%= entityAngularName %>FormRawValue);
+<%_ } else { _%>
+    return form.getRawValue() as I<%= entityAngularName %> | New<%= entityAngularName %>;
+<%_ } _%>
+  }
+
+  resetForm(form: <%= entityAngularName %>FormGroup, <%= entityInstance %>: <%= entityAngularName %>FormGroupInput): void {
+    const <%= entityInstance %>RawValue =
+<%_ if (fieldsContainTimed) { _%>
+      this.convert<%= entityAngularName %>To<%= entityAngularName %>RawValue(
+<%_ } _%>
+<%_ if (containDefaultProperties) { _%>
+        {...this.getFormDefaults(), ...<%= entityInstance %> }
+<%_ } else { _%>
+        <%= entityInstance %>
+<%_ } _%>
+<%_ if (fieldsContainTimed) { _%>
+      )
+<%_ } _%>
+    ;
+    form.reset({
+      ...<%= entityInstance %>RawValue,
+<%_ for (const field of fields.filter(field => field.id)) { _%>
+      <%= field.fieldName %>: { value: <%= entityInstance %>RawValue.<%= field.fieldName %>, disabled: <% if (field.autoGenerate) { %>true<% } else { %><%= entityInstance %>RawValue.<%= fieldName %> !== null<% } %> },
+<%_ } _%>
+    } as any /* cast to workaround https://github.com/angular/angular/issues/46458 */);
+  }
+<%_ if (containDefaultProperties) { _%>
+
+  private getFormDefaults(): <%= entityAngularName %>FormDefaults {
+  <%_ if (fields.some(field => field.fieldTypeTimed)) { _%>
+      const currentTime = dayjs();
+  <%_ } _%>
+
+    return {
+  <%_ for (field of fields) {
+        const { fieldName, fieldTypeBoolean, fieldTypeTimed, fieldTypeLocalDate } = field;
+  _%>
+    <%_ if (field.id) { _%>
+      <%= fieldName %>: null,
+    <%_ } else if (fieldTypeBoolean) { _%>
+      <%= fieldName %>: false,
+    <%_ } else if (fieldTypeTimed) { _%>
+      <%= fieldName %>: currentTime,
+    <%_ } _%>
+  <%_ } _%>
+  <%_ for (const relationship of relationships.filter(({ ownerSide, relationshipManyToMany }) => ownerSide || relationshipManyToMany)) {
+        const { relationshipRequired, propertyName, collection, otherEntity, relationshipName } = relationship;
+  _%>
+    <%_ if (collection) { _%>
+      <%= propertyName %>: [],
+    <%_ } _%>
+  <%_ } _%>
+    };
+  }
+<%_ } _%>
+<%_ if (fieldsContainTimed) { _%>
+
+  private convert<%= entityAngularName %>RawValueTo<%= entityAngularName %>(raw<%= entityAngularName %>: <%= entityAngularName %>FormRawValue | New<%= entityAngularName %>FormRawValue): I<%= entityAngularName %> | New<%= entityAngularName %> {
+    return {
+      ...raw<%= entityAngularName %>,
+<%_ for (field of fields) {
+      const { fieldName, fieldTypeTimed } = field;
+_%>
+  <%_ if (fieldTypeTimed) { _%>
+      <%= fieldName %>: dayjs(raw<%= entityAngularName %>.<%= fieldName %>, DATE_TIME_FORMAT),
+  <%_ } _%>
+<%_ } _%>
+    };
+  }
+
+  private convert<%= entityAngularName %>To<%= entityAngularName %>RawValue(<%= entityInstance %>: I<%= entityAngularName %> | (Partial<New<%= entityAngularName %>> & <%= entityAngularName %>FormDefaults)): <%= entityAngularName %>FormRawValue | PartialWithRequiredKeyOf<New<%= entityAngularName %>FormRawValue> {
+    return {
+      ...<%= entityInstance %>,
+<%_ for (field of fields) {
+      const { fieldName, fieldTypeTimed } = field;
+_%>
+  <%_ if (fieldTypeTimed) { _%>
+      <%= fieldName %>: <%= entityInstance %>.<%= fieldName %> ? <%= entityInstance %>.<%= fieldName %>.format(DATE_TIME_FORMAT) : undefined,
+  <%_ } _%>
+<%_ } _%>
+<%_ for (const relationship of relationships.filter(({ ownerSide, relationshipManyToMany }) => ownerSide || relationshipManyToMany)) {
+      const { relationshipRequired, propertyName, collection } = relationship;
+_%>
+  <%_ if (collection) { _%>
+      <%= propertyName %>: <%= entityInstance %>.<%= propertyName %> ?? [],
+  <%_ } _%>
+<%_ } _%>
+    };
+  }
+<%_ } _%>
+}