fam-archetype-app 0.0.1

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/infrastructure/inbound/pages/list/Xxx_list_ts.vm

@@ -0,0 +1,430 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+#parse("include/macros.vm")
+##---------------------------------------------------
+import { Component, Input, SimpleChanges, Type } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { ${entityName} } from '../../../../domain/#kebabCase("${entityName}").entity';
+import { Search${entityName}UseCase } from '../../../../application/search-#kebabCase("${entityName}").use-case';
+import { Delete${entityName}UseCase } from '../../../../application/delete-#kebabCase("${entityName}").use-case';
+import { PrimeNgTranslationPipe } from '@core/pipes/primeng-translation.pipe';
+import { Button } from 'primeng/button';
+import { DibaTableComponent } from '@shared/table/diba-table/diba-table.component';
+import { JsonApiMeta } from '@shared/models/json-api-meta.entity';
+import { UtilsService } from '@shared/service/utils.service';
+import { Column } from '@shared/table/domain/column.entity';
+import { ColumnType } from '@shared/table/domain/column-type.enum';
+import { DropdownModule } from 'primeng/dropdown';
+import { CalendarModule } from 'primeng/calendar';
+import { InputTextModule } from 'primeng/inputtext';
+import { FormsModule } from '@angular/forms';
+import { Filter } from '@shared/filters/domain/filter.entity';
+import { FilterType } from '@shared/filters/domain/filter-type.enum';
+import { DibaFiltersComponent } from '@shared/filters/diba-filters/diba-filters.component';
+import { FilterOperator } from '@shared/filters/domain/filter-operator.enum';
+import { ${entityName}DetailComponent } from '../#kebabCase("${entityName}")-detail/#kebabCase("${entityName}")-detail.component';
+
+#foreach( $link in $toOneLinks )
+#if( ${entityName} != ${link.fieldType})
+#if( $velocityCount == 1 )
+//to One
+#end
+import { ${link.fieldType} } from '../../../../../#kebabCase("${link.fieldType}")/domain/#kebabCase("${link.fieldType}").entity';
+import { Search${link.fieldType}UseCase } from '@modules/#kebabCase("${link.fieldType}")/application/search-#kebabCase("${link.fieldType}").use-case';
+#end
+#end
+
+@Component({
+  selector: 'app-#kebabCase("${entityName}")-list',
+  imports: [
+    CommonModule, 
+    RouterModule, 
+    PrimeNgTranslationPipe, 
+    Button,
+    DibaTableComponent, 
+    DibaFiltersComponent,
+    DropdownModule, 
+    CalendarModule, 
+    InputTextModule, 
+    FormsModule],
+  templateUrl: './#kebabCase("${entityName}")-list.component.html',
+  styleUrl: './#kebabCase("${entityName}")-list.component.scss'
+})
+export class ${entityName}ListComponent {
+
+  // NUEVO: modo embebido y parámetros opcionales
+  @Input() embedded = false;                     // si true: estamos dentro del detalle de zona
+  @Input() parentId?: string | number;             // id de la zona a fijar
+  @Input() showFilters = true;                   // esconder barra de filtros si se quiere
+  @Input() pageSizeEmbedded = 5;                 // tamaño de página por defecto en embebido
+  @Input() parent = "";                            // Entidad padre que llama al listado envedido
+  detailComponent: Type<any> = ${entityName}DetailComponent;
+
+  // Active filters
+  FilterType = FilterType;
+  filters: Filter[] = [
+#set( $existMandatoryAtribiute = false)
+#foreach( $attribute in $mandatoryInList )
+#set( $existMandatoryAtribiute = true)
+#if( $attribute.type == "String"  || $attribute.type == "string" )
+    {
+      label: "#snakeLowerCase("${attribute.name}")",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.TEXT,
+      operator: FilterOperator.LIKE,
+      value: ""
+    }
+#elseif( $attribute.type == "long" || $attribute.type == "Long" || $attribute.type == "int" || $attribute.type == "integer" || $attribute.type == "Integer")
+    {
+      label: "#snakeLowerCase("${attribute.name}")_MIN",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.NUMBER,
+      operator: FilterOperator.GTE,
+      value: ""
+    },
+    {
+      label: "#snakeLowerCase("${attribute.name}")_MAX",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.NUMBER,
+      operator: FilterOperator.LTE,
+      value: ""
+    }
+#elseif( $attribute.type == "LocalDate" || $attribute.type == "localdate" || $attribute.type == "Date" || $attribute.type == "date")
+    {
+      label: "#snakeLowerCase("${attribute.name}")_FROM",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.DATE,
+      operator: FilterOperator.GTE,
+      value: ""
+    },
+    {
+      label: "#snakeLowerCase("${attribute.name}")_TO",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.DATE,
+      operator: FilterOperator.LTE,
+      value: ""
+    }
+#elseif( $attribute.type == "Boolean" || $attribute.type == "boolean")
+    {
+      label: "#snakeLowerCase("${attribute.name}")",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.BOOLEAN,
+      operator: FilterOperator.EQ,
+      value: "",
+      selectValues: [
+        { label: '\u2009', value: null }, // Empty option
+        { label: 'Sí', value: true }, 
+        { label: 'No', value: false }]
+    }
+#else 
+    {
+      label: "#snakeLowerCase("${attribute.name}")",
+      name:"#snakeLowerCase("${attribute.name}")",
+      type: FilterType.TEXT,
+      operator: FilterOperator.LIKE,
+      value: ""
+    }
+#end
+#comma( $foreach.hasNext )
+#end
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($fieldShowFront = $link.tagValue("fieldShowFront", "id"))
+#if( $existMandatoryAtribiute == true && $velocityCount == 1)
+    , 
+#end
+    {
+      label: "#snakeLowerCase("${link.fieldName}").#snakeLowerCase("${fieldShowFront}")",
+      name:"#snakeLowerCase("${link.fieldName}").id",
+      type: FilterType.SELECT,
+      operator: FilterOperator.EQ,
+      value: "",
+       selectValues: []
+    } #comma( $foreach.hasNext )
+#end
+  ];
+
+  //List Data
+  #camelCase("${entityName}")List: ${entityName}[] = [];
+  meta: JsonApiMeta = {
+    page: {
+      size: 5, //Rows
+      totalElements: 5, //Total Rows
+      totalPages: 1, //Total Pages
+      number: 1 //Current Page
+    }
+  };
+
+  //List params
+  rowsPerPageOptions: number[] = [5, 10, 20, 50, 100];
+
+  //List Columns
+  columnasMostrar: Column[] = [
+#set( $existMandatoryAtribiute = false)
+#foreach( $attribute in $mandatoryInList )
+#set( $existMandatoryAtribiute = true)
+    {
+        field: '#snakeLowerCase("${attribute.name}")',
+        header: '#snakeLowerCase("${attribute.name}")',
+        type: #columnType("${attribute.type}"),
+#set($pipe = $attribute.tagValue("pipe", "undefined"))
+#set($pipeFormatted = "#if($pipe)'$pipe'#else undefined#end")
+        pipe: $pipeFormatted
+    }#comma( $foreach.hasNext )
+#end
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($fieldShowFront = $link.tagValue("fieldShowFront", "id"))
+#if( $existMandatoryAtribiute == true && $velocityCount == 1)
+    , 
+#end
+    {
+        field: '#snakeLowerCase("${link.fieldName}").#snakeLowerCase("${fieldShowFront}")',
+        header: '#snakeLowerCase("${link.fieldName}").#snakeLowerCase("${fieldShowFront}")',
+        type: ColumnType.TEXT,
+#set($pipe = $link.tagValue("pipe", "undefined"))
+#set($pipeFormatted = "#if($pipe)'$pipe'#else undefined#end")
+        pipe: $pipeFormatted
+    } #printTagAsColumnObjects($link "extraField") #comma( $foreach.hasNext )
+#end];
+  columnasOcultar: Column[] = [
+#set( $existOptionalAtribiute = false)
+#foreach( $attribute in $optionalInList )
+#set( $existOptionalAtribiute = true)
+    {
+        field: '#snakeLowerCase("${attribute.name}")',
+        header: '#snakeLowerCase("${attribute.name}")',
+        type: #columnType("${attribute.type}"),
+#set($pipe = $attribute.tagValue("pipe", "undefined"))
+#set($pipeFormatted = "#if($pipe)'$pipe'#else undefined#end")
+        pipe: $pipeFormatted
+    } #comma( $foreach.hasNext )
+#end
+#foreach( $link in $optionalToOneLinksInList )
+#set($fieldShowFront = $link.tagValue("fieldShowFront", "id"))
+#if( $existOptionalAtribiute == true && $velocityCount == 1)
+    , 
+#end
+    {
+        field: '#snakeLowerCase("${link.fieldName}").#snakeLowerCase("${fieldShowFront}")',
+        header: '#snakeLowerCase("${link.fieldName}").#snakeLowerCase("${fieldShowFront}")',
+        type: ColumnType.TEXT,
+#set($pipe = $link.tagValue("pipe", "undefined"))
+#set($pipeFormatted = "#if($pipe)'$pipe'#else undefined#end")
+        pipe: $pipeFormatted
+    } #printTagAsColumnObjects($link "extraField") #comma( $foreach.hasNext )
+    
+#end];
+  //Search Params
+  include: string[] = [
+#foreach( $link in $toOneLinks )
+    '#snakeLowerCase("${link.fieldName}")'  #printTagValueAsList($link "extraInclude") #comma( $foreach.hasNext )
+#end
+  ];
+  pagination: {page: number, limit: number} = { page: 1, limit: 10 };
+  sort: string = '';
+  // CRUD Operations
+  selectRows: boolean = true;
+  allowEdit: boolean = true;
+  allowDelete: boolean = true; 
+  allowCreate: boolean = true;
+  loading: boolean = false;
+#set( $existLinkInListAttribute = false )
+#foreach( $attribute in $mandatoryInList )
+  #if( $attribute.hasTag("linkInList") && $attribute.tagValue("linkInList") == "true" )
+    #set( $existLinkInListAttribute = true )
+    #set( $linkAttribute = $attribute.name )
+    #break
+  #end
+  #if($velocityCount == 1 && $existLinkInListAttribute == false)
+    #set( $linkAttribute = $attribute.name )
+  #end
+#end
+#set( $existLinkInListToOne = false )
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($isLinkInList = $link.tagValueAsBoolean("linkInList", false))
+#if( $isLinkInList )
+    #set( $existLinkInListAttribute = true )
+    #set( $existLinkInListToOne = true )
+    #set( $fieldShowFrontLinkItem = $link.tagValue("fieldShowFront", "id"))
+    #set( $linkAttribute = $link.fieldName )
+    #break
+  #end
+#end
+#set( $existLinkInListAttribute = true )
+
+#if( $existLinkInListAttribute )
+#if( !$existLinkInListToOne)
+  linkColumn: string = "#snakeLowerCase($linkAttribute)";
+#else
+  linkColumn: string = '#snakeLowerCase("${linkAttribute}").#snakeLowerCase("${fieldShowFrontLinkItem}")';
+#end
+#end
+
+  constructor(
+    private search${entityName}: Search${entityName}UseCase,
+    private delete${entityName}: Delete${entityName}UseCase,
+    private utils: UtilsService
+#foreach( $link in $mandatoryToOneLinksInList )
+#if( ${entityName} != ${link.fieldType})
+    , private search#camelCaseCapitalize("${link.fieldName}"): Search#camelCaseCapitalize("${link.fieldName}")UseCase
+#end#end
+  ) {
+      this.pagination = { page: this.meta.page.number, limit: this.meta.page.size };  
+  }
+
+  async ngOnInit() {
+    console.log('${entityName}ListComponent initialized');
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($fieldShowFront = $link.tagValue("fieldShowFront", "id"))
+    this.loadDropdownFilter('#snakeLowerCase("${link.fieldName}").#snakeLowerCase("${fieldShowFront}")', '#snakeLowerCase("${fieldShowFront}")', this.search#camelCaseCapitalize("${link.fieldName}"));
+#end
+    // si embebido, ajusta paginación y filtros iniciales
+    if (this.embedded) {
+      this.meta.page.size = this.pageSizeEmbedded;
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($isParentEntity = $link.tagValueAsBoolean("isParentEntity", false))
+#if( $isParentEntity )
+      // opcional: si tienes array 'filters' predefinido, quita el filtro por la entidad padre del usuario
+      this.filters = (this.filters ?? []).filter(f => f.name !== '#snakeLowerCase("${link.fieldName}").id');
+#end#end
+      
+      // primer search con filtro fijo de zona
+      this.newSearch(this.filters ?? []);
+    } else {
+      // comportamiento actual
+      this.newSearch(this.filters ?? []);
+    }
+    this.search();
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($isParentEntity = $link.tagValueAsBoolean("isParentEntity", false))
+#if( $isParentEntity )
+    // si cambia la parentId en modo embebido, relanza la búsqueda
+    if (this.embedded && changes['parentId'] && !changes['parentId'].firstChange) {
+      this.meta.page.number = 1;
+      this.newSearch(this.filters ?? []);
+    }
+#end#end
+  }
+
+
+  // Filtro fijo por id entidad padre cuando estamos embebidos
+  private get fixedParentFilter(): Filter[] {
+    if (!this.embedded || !this.parentId) return [];
+#set($firstParent = true)
+#foreach( $link in $mandatoryToOneLinksInList )
+#set($isParentEntity = $link.tagValueAsBoolean("isParentEntity", false))
+#if( $isParentEntity ) 
+#if( $firstParent ) 
+#set($firstParent = false)  
+    if(this.parent === "#camelCaseCapitalize("${link.fieldType}")") {
+      return [{
+        label: 'parent_filter', // el label es decorativo
+        name: '#snakeLowerCase("${link.fieldName}").id',
+        operator: FilterOperator.EQ,
+        value: String(this.parentId),
+        type: FilterType.TEXT
+      }];
+    }
+#else
+    else if(this.parent === "#camelCaseCapitalize("${link.fieldType}")") {
+      return [{
+        label: 'parent_filter', // el label es decorativo
+        name: '#snakeLowerCase("${link.fieldName}").id',
+        operator: FilterOperator.EQ,
+        value: String(this.parentId),
+        type: FilterType.TEXT
+      }];
+    }
+#end
+#end#end
+#if( !$firstParent ) 
+    else {
+      return [];
+    }
+#else
+    return [];
+#end
+    
+  }
+
+  async newSearch(event: any) {
+    console.log("Event : " + JSON.stringify(event.filters));
+    if(event.filters !== undefined) {
+      const effectiveFilters = [...(event.filters ?? []), ...this.fixedParentFilter];
+      this.filters = effectiveFilters;
+    } else if(this.fixedParentFilter.length > 0) {
+      const effectiveFilters = [...this.fixedParentFilter];   
+      this.filters = effectiveFilters;
+    }
+    this.meta.page.number = 1; // Reset to first page
+    this.search();
+  }
+
+  async search() {
+    this.loading = true;
+    this.pagination = { page: this.meta.page.number, limit: this.meta.page.size };
+    let apiResponse = await this.search${entityName}.execute(this.filters, this.include, this.pagination, this.sort);
+    this.#camelCase("${entityName}")List = apiResponse.data;
+    this.meta = apiResponse.meta;
+    this.loading = false;
+    console.log("Show #camelCase("${entityName}") - list :", this.#camelCase("${entityName}")List);
+  }
+
+  async cleanFilters(event: any) {
+    console.log("Event : " + JSON.stringify(event.filters));
+    this.filters = event.filters;
+  }
+
+  delete(id: string): void {
+    this.delete${entityName}.execute(id)
+      .then(async () => {
+        this.search();
+      })
+      .catch(error => { 
+        console.error('Error deleting ${entityName}:', error);
+      });
+  }
+
+  onPageChange(event: any) {
+    //Update pagination based on the event
+    this.meta.page.number = event.page;
+    this.meta.page.size = event.rows;
+    // Call the search method to fetch data for the new page
+    this.search();
+  }
+
+  onSortChange(event: any) {
+    //Update sort based on the event
+    this.sort = this.utils.multiSortMetaToJsonApiSort(event.multisortmeta);
+    // Call the search method to fetch data for the new sort
+    this.search();
+  }
+
+  onDeleteEvent(event: any) {
+    for (const id of event) {
+      console.log("Eliminar registro con id: " + id);
+      this.delete(id);
+    }
+  }
+
+  onPageUpdate(event: any) {
+    console.log("Actualizar listado tras edición o creación : " + event);
+    this.search();
+  }
+
+  async loadDropdownFilter(label: string, field: string, searchService: any) {
+    // Load info for dropdown filter
+    const optionsZona = this.utils.mapJsonApiToDropdownOptions((await searchService.execute()).data, field);
+    // Añadir la opción vacía al principio
+    const optionsWith = [{ label: '\u2009', value: null }, ...optionsZona];
+    const filtro = this.filters.find(f => f.label === label);
+    if (filtro) {
+      filtro.selectValues = optionsWith;
+    }
+  }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/infrastructure/inbound/resources/Xxx_resource_ts.vm

@@ -0,0 +1,43 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+#parse("include/macros.vm")
+##---------------------------------------------------
+
+import { ${entityName} } from '../../../domain/#kebabCase("${entityName}").entity';
+#foreach( $link in $toOneLinks )
+#if(${entityName}!= $link.fieldType)
+import { ${link.fieldType} } from '../../../../#kebabCase("$link.fieldType")/domain/#kebabCase("$link.fieldType").entity';
+#end
+#end
+#foreach( $link in $toManyLinks )
+#set( $genericType = "#extractGenericType($link.fieldType)" )
+#if(${entityName}!= $genericType)
+import { $genericType } from '../../../../#kebabCase("$genericType")/domain/#kebabCase("$genericType").entity';
+#end
+#end
+
+export class ${entityName}Resource implements ${entityName} {
+    id?: string;
+#foreach( $attribute in $entity.nonKeyAttributes )
+#set( $attributeType = $attribute.wrapperType )
+    #snakeLowerCase("$attribute.name")#if($attribute.isNotNull())?#end: #javaTypeToTsType("$attributeType") #if(!$attribute.isNotNull())#tsDefaultValue("$attributeType")#end;
+#end
+#foreach( $link in $toOneLinks )
+#if( $velocityCount == 1 )
+    // toOne
+#end
+    #snakeLowerCase("${link.fieldName}"): $link.fieldType = {} as $link.fieldType;
+#end
+#foreach( $link in $toManyLinks )
+#if( $velocityCount == 1 )
+    // toMany
+#end
+    #snakeLowerCase("${link.fieldName}"): #extractGenericType("$link.fieldType")[] = [];
+#end
+
+  constructor(init?: Partial<${entityName}Resource>) {
+    Object.assign(this, init);
+  }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/infrastructure/outbound/Xxx_repository_impl_ts.vm

@@ -0,0 +1,162 @@
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+#parse("include/macros.vm")
+##---------------------------------------------------
+import { ${entityName}RepositoryInterface } from '../../domain/#kebabCase("${entityName}").repository.interface';
+import { ${entityName} } from '../../domain/#kebabCase("${entityName}").entity';
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom, Observable } from 'rxjs';
+import { environment } from '@root/environments/environment';
+import { Jsona } from 'jsona';
+import { ${entityName}JsonaMapper } from '../inbound/mappers/#kebabCase("${entityName}")-jsona.mapper';
+import { UtilsService } from '@shared/service/utils.service';
+import { JsonApiMeta } from '@shared/models/json-api-meta.entity';
+import { mapJsonApiMeta } from '@shared/mappers/json-api-meta.mapper';
+import { Filter } from '@shared/filters/domain/filter.entity';
+
+@Injectable({ providedIn: 'root' })
+export class ${entityName}RepositoryImpl implements ${entityName}RepositoryInterface {
+
+    private basePath = environment.apiBaseUrl; // URL base de la API
+    private resource = '${resourceContext}'; // Recurso al que accedera de la API
+    private formatter = new Jsona({
+        modelPropertiesMapper: new ${entityName}JsonaMapper()
+    });
+#[[
+    private apiUrl = `${this.basePath}${this.resource}`; // URL completa de la API
+]]#
+
+    private withType(#camelCase("${entityName}"): ${entityName}) {
+        return { ...#camelCase("${entityName}"), type: '${resourceContext}' };
+    }    
+    
+    constructor(
+        private http: HttpClient,
+        private utils: UtilsService
+    ) {}
+#if($hasFileType)
+    async create(
+        #camelCase("${entityName}"): ${entityName}
+        , opts?: { file?: File; field?: string }
+    ): Promise<${entityName}> {
+#else
+    async create(#camelCase("${entityName}"): ${entityName}): Promise<${entityName}> {
+#end
+        const payload = this.formatter.serialize({
+            stuff: this.withType(#camelCase("${entityName}"))
+        });
+#if($hasFileType)
+        if (opts?.file) {
+            const formData = new FormData();
+            // Parte "data": JSON:API como Blob con su content-type
+            formData.append(
+                'data',
+                new Blob([JSON.stringify(payload)], { type: 'application/json' })
+            );
+            
+            // Parte "file"
+            formData.append('file', opts.file);
+
+            // Parte "field" (opcional, por si el backend lo usa)
+            if (opts.field) formData.append('field', opts.field);
+
+            return await firstValueFrom(this.http.post<any>(this.apiUrl, formData));
+        } else {
+            return await firstValueFrom(
+                this.http.post<any>(
+                    this.apiUrl,
+                    payload,
+                    { headers: { 'Content-Type': 'application/vnd.api+json' } }
+                )
+            );
+        }
+#else
+        return await firstValueFrom(
+            this.http.post<any>(
+                this.apiUrl,
+                payload,
+                { headers: { 'Content-Type': 'application/vnd.api+json' } }
+            )
+        );
+#end
+    }
+
+    async delete(id: string): Promise<void> {
+        await firstValueFrom(#[[this.http.delete<any>(`${this.apiUrl}/${id}`)]]#);
+    }
+
+#if($hasFileType)
+    async update(
+        #camelCase("${entityName}"): ${entityName},
+        opts?: { file?: File; field?: string }
+    ): Promise<void> {
+#else
+    async update(#camelCase("${entityName}"): ${entityName}): Promise<void> {
+#end
+        const url = `#[[${this.apiUrl}/${]]##camelCase("${entityName}").id}`;
+        const payload = this.formatter.serialize({
+            stuff: this.withType(#camelCase("${entityName}"))
+        });
+#if($hasFileType)
+        if (opts?.file) {
+            const formData = new FormData();
+            // Parte "data": JSON:API como Blob con su content-type
+            formData.append(
+                'data',
+                new Blob([JSON.stringify(payload)], { type: 'application/json' })
+            );
+            
+            // Parte "file"
+            formData.append('file', opts.file);
+
+            // Parte "field" (opcional, por si el backend lo usa)
+            if (opts.field) formData.append('field', opts.field);
+
+            await firstValueFrom(this.http.put<any>(url, formData));
+        } else {
+            await firstValueFrom(
+                this.http.put<any>(url, payload, {
+                    headers: { 'Content-Type': 'application/vnd.api+json' }
+                })
+            );
+        }
+#else
+        await firstValueFrom(
+            this.http.put<any>(
+                url, 
+                payload, 
+                { headers: { 'Content-Type': 'application/vnd.api+json' } }
+            )
+        );
+#end
+    }
+
+    async find(id: string): Promise<${entityName} | null> {
+        const response = await firstValueFrom(this.http.get<any>(this.apiUrl+"/"+id));
+        return this.formatter.deserialize(response) as ${entityName} | null;
+    }
+
+    async search(
+        filter?: Filter[], 
+        include?: string[], 
+        pagination?: { page: number; limit: number },
+        sort?: string
+    ): Promise<{data: ${entityName}[], meta: JsonApiMeta}> {
+        const params = this.utils.buildSearchParams(filter, include, pagination, sort);
+        const response = await firstValueFrom(this.http.get<any>(this.apiUrl, { params }));
+        return { data: this.formatter.deserialize(response) as ${entityName}[], meta: mapJsonApiMeta(response) };
+    }
+#if($hasFileTypeinNAS)
+    async downloadFile(id: number): Promise<Blob> {
+        const url = `#[[${this.apiUrl}/${id}/download]]#`;
+        
+        // Creamos el observable pero no nos suscribimos aún
+        const request$ = this.http.get(url, { responseType: 'blob' });
+
+        // Convertimos el observable a promesa y esperamos el último valor (que es la respuesta HTTP)
+        return await firstValueFrom(request$);
+    }
+#end
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/test_code.vm

@@ -0,0 +1,3 @@
+#foreach( $entity in $project.entities )
+    $entity.name / 
+#end