fam-archetype-app 0.0.1

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/include/macros.vm

@@ -0,0 +1,218 @@
+## ############################################################################
+## Macros
+## ############################################################################
+## Macro: camelCase. Convierte un fieldName a camelCase
+#macro( camelCase $fieldName )
+#set( $result = $fieldName.replaceAll("[-_ ]+([a-zA-Z0-9])", "$1") )
+$fn.uncapitalize($result)#end
+## Macro: camelCaseCapitalize. Convierte un fieldName a camelCaseCapitalize
+#macro( camelCaseCapitalize $fieldName )
+#set( $result = $fieldName.replaceAll("[-_ ]+([a-zA-Z0-9])", "$1") )
+$fn.capitalize($result)#end
+## Macro: camelCaseUpper. Convierte un fieldName a camelCase y lo convierte todo a mayúsculas
+#macro( camelCaseUpper $fieldName )
+#set( $result = $fieldName.replaceAll("[-_ ]+([a-zA-Z0-9])", "$1") )
+$fn.uncapitalize($result).toUpperCase()#end
+## Macro: kebabCase. Convert a fieldName to kebabCase
+#macro(kebabCase $fieldName)
+$fieldName.replaceAll("([a-z])([A-Z])", "$1-$2").toLowerCase()#end
+## Macro: snakeLowerCase. Convert a fieldName to SnakeCase
+#macro( snakeLowerCase $fieldName )
+#set( $fieldNameUncapitalized = $fn.uncapitalize($fieldName) )
+$fieldNameUncapitalized.replaceAll("([A-Z])", "_$1").toLowerCase()#end
+## Macro: snakeCase. Convert a fieldName to SnakeCase
+#macro( snakeUpperCase $fieldName )
+#set( $fieldNameUncapitalized = $fn.uncapitalize($fieldName) )
+$fieldNameUncapitalized.replaceAll("([A-Z])", "_$1").toUpperCase()#end
+## Macro: operator. Returns the mandatory 'of' or optional 'fromNullable' operator.
+#macro( operator $isNotBlank )#if($isNotBlank)of#{else}fromNullable#end#end
+## Macro: resolveType. Returns the corresponding type of attribute.
+#macro( resolveType $attribute )
+#if( $attribute.isTemporalType() )
+#set( $type = "String" )
+#else
+#set( $type = $attribute.type )
+#end
+$type#end
+## Macro: resolveValue. Returns the corresponding value of attribute.
+#macro( resolveValue $attribute )
+#if( $attribute.isTemporalType() )
+#set( $value = "toDatetime()" )
+#else
+#set( $value = "value()" )
+#end
+$value#end
+## Macro: comma. Returns the comma (,) separator between arguments (attributes only)
+#macro( comma $hasNext )#if( $hasNext ),#end#end
+## Macro: comma. Returns the comma (,) separator between arguments (attributes + links)
+#macro( commaAndContinue $hasNext )#if( $hasNext || !$toOneLinks.isEmpty() || !$toManyLinks.isEmpty() ),#end#end
+## Macro: addConstraintsAnnotationsImports. Add all constraints annotations imports for aggregate's field
+#macro( addConstraintsAnnotationsImports )
+#set( $addedImportNotBlank = false)
+#set( $addedImportNotNull = false)
+#set( $addedImportSize = false)
+#set( $addedImportPattern = false)
+#foreach( $attribute in $entity.attributes )
+## Check if existe some attribute with Not Blank constraint
+#if( !$addedImportNotBlank )
+#set( $attributePostable = $attribute.tagValueAsBoolean( "postable", true ) )
+#set( $logicalDeletion = $entity.tagValue("AggregateDeletion", "physical") == "logical" )
+#if( $attributePostable && $attribute.isNotBlank())
+import jakarta.validation.constraints.NotBlank;
+#set( $addedImportNotBlank = true)
+#end
+#end
+## Check if existe some attribute with Not Null constraint
+#if( !$addedImportNotNull )
+#set( $attributePostable = $attribute.tagValueAsBoolean( "postable", true ) )
+#if( ($attributePostable && $attribute.isNotNull()) || $logicalDeletion )
+import jakarta.validation.constraints.NotNull;
+#set( $addedImportNotNull = true)
+#end
+#end
+## Check if existe some attribute with Size constraint
+#if( !$addedImportSize )
+#set( $attributePostable = $attribute.tagValueAsBoolean( "postable", true ) )
+#set( $attributeUpdatable = $attribute.tagValueAsBoolean( "updatable", true ) )
+#if( $attribute.isStringType() && ($attributePostable || $attributeUpdatable) && $attribute.maxLength != "")
+import jakarta.validation.constraints.Size;
+#set( $addedImportSize = true)
+#end
+#end
+## Check if existe some attribute with Pattern constraint
+#if( !$addedImportPattern )
+#set( $attributePostable = $attribute.tagValueAsBoolean( "postable", true ) )
+#set( $attributeUpdatable = $attribute.tagValueAsBoolean( "updatable", true ) )
+#if( ($attributePostable || $attributeUpdatable) && $attribute.pattern != "")
+import jakarta.validation.constraints.Pattern;
+#set( $addedImportPattern = true)
+#end
+#end
+## Check if all imports was added to finish foreach
+#if( $addedImportNotBlank && $addedImportNotNull && $addedImportSize && $addedImportPattern)
+#break
+#end
+## End foreach $entity.attributes
+#end 
+## End macro addConstraintsAnnotationsImports
+#end
+## Macro: addConstraintsAnnotations. Add all constraints annotations for aggregate's field
+#macro( addConstraintsAnnotations $attribute )
+#set( $attributePostable = $attribute.tagValueAsBoolean( "postable", true ) )
+#set( $attributeUpdatable = $attribute.tagValueAsBoolean( "updatable", true ) )
+#set( $attributeReadable = $attribute.tagValueAsBoolean( "readable", true ) )
+#set( $attributeFilterable = $attribute.tagValueAsBoolean( "filterable", true ) )
+#set( $validators = [] )
+#if ( $attributePostable )
+#set( $z = $validators.add("CreateValidator.class") )
+#end
+#if ( $attributeUpdatable )
+#set( $z = $validators.add("UpdateValidator.class") )
+#end
+#if( $attributePostable || $attributeUpdatable )
+#if($attribute.isNotBlank())
+    @NotBlank(message = "The field <#snakeLowerCase( ${attribute.name} )> is mandatory", groups = { $fn.join($validators, ", ") })
+#elseif( $attribute.isNotNull() )
+    @NotNull(message = "The field <#snakeLowerCase( ${attribute.name} )> is mandatory", groups = { $fn.join($validators, ", ") })
+#end
+#if( $attribute.isStringType() && $attribute.maxLength != "" )
+    @Size(
+        message = "The field <#snakeLowerCase( ${attribute.name} )> has exceeded maximum length (${attribute.maxLength} characters)",
+        max = ${attribute.maxLength},
+        groups = { $fn.join($validators, ", ") }
+    )
+#end
+#if( $attribute.pattern != "" )
+    @Pattern(
+        message = "The field <#snakeLowerCase( ${attribute.name} )> does not match the pattern: ${attribute.pattern})",
+        regexp = "${attribute.pattern}",
+        groups = { $fn.join($validators, ", ") }
+    )
+#end
+#end
+#end
+## Macro: addResourceFieldAnnotations. Add all resource's field annotations
+#macro( addResourceFieldAnnotations $attribute )
+#set( $attributePostable = $attribute.tagValueAsBoolean( "postable", true ) )
+#set( $attributeUpdatable = $attribute.tagValueAsBoolean( "updatable", true ) )
+#set( $attributeReadable = $attribute.tagValueAsBoolean( "readable", true ) )
+#set( $attributeFilterable = $attribute.tagValueAsBoolean( "filterable", true ) )
+#if( $attributePostable || $attributeUpdatable )
+#if( $attributeReadable )
+    @JsonProperty(access = Access.READ_WRITE)
+#else
+    @JsonProperty(access = Access.WRITE_ONLY)
+#end
+    @JsonApiField(filterable = $attributeFilterable)
+#elseif( $attributeReadable )
+    @JsonProperty(access = Access.READ_ONLY)
+    @JsonApiField(filterable = $attributeFilterable)
+#else
+    @JsonIgnore
+#end
+#end
+## Macro: javaTypeToTsType. Convierte un tipo de Java a su equivalente en TypeScript
+#macro( javaTypeToTsType $javaType )
+#if( $javaType == "String" )
+string#elseif( $javaType == "Long" || $javaType == "Integer" || $javaType == "Double" || $javaType == "Float" || $javaType == "BigDecimal" )
+number#elseif( $javaType == "Boolean" || $javaType == "boolean" )
+boolean#elseif( $javaType == "LocalDate" || $javaType == "LocalDateTime" || $javaType == "Date" )
+string#elseif( $javaType == "byte[]" )
+Uint8Array#else
+any#end#end
+## Macro: extractGenericType. Extrae el tipo entre < > de un tipo genérico
+#macro( extractGenericType $type )
+#set( $match = $type.replaceAll(".*<([a-zA-Z0-9_]+)>.*", "$1") )
+$match#end
+## Macro: tsDefaultValue. Devuelve un valor de inicialización según el tipo Java
+#macro( tsDefaultValue $javaType )
+#if( $javaType == "String" )
+ = ''#elseif( $javaType == "Long" || $javaType == "Integer" || $javaType == "Double" || $javaType == "Float" || $javaType == "BigDecimal" )
+ = 0#elseif( $javaType == "Boolean" || $javaType == "boolean" )
+ = false#elseif( $javaType == "LocalDate" || $javaType == "LocalDateTime" || $javaType == "Date" )
+ = ''#elseif( $javaType == "byte[]" )
+ = new Uint8Array()#else
+ = undefined#end#end
+## Macro: Devuelve el tipo de columna de un campo del modelo
+#macro( columnType $input )
+  #set($type = "")
+  #if($input == "string" || $input == "String")
+    #set($type = "ColumnType.TEXT")
+  #elseif($input == "integer" || $input == "Integer" || $input == "int" || $input == "long" || $input == "Long" || $input == "double" || $input == "Double" || $input == "float" || $input == "Float" || $input == "BigDecimal")
+    #set($type = "ColumnType.NUMBER")
+  #elseif($input == "boolean" || $input == "Boolean")
+    #set($type = "ColumnType.BOOLEAN")
+  #elseif($input == "LocalDate" || $input == "localdate" || $input == "Date" || $input == "date")
+    #set($type = "ColumnType.DATE")
+  #elseif($input == "byte[]")
+    #set($type = "ColumnType.FILE")
+  #else
+    #set($type = "ColumnType.TEXT")
+  #end
+  $type
+#end
+## Extract and convert string in to list
+#macro(printTagValueAsList $element $tagName)
+  #set($rawValue = $element.tagValue($tagName))
+  #if($rawValue && $rawValue.trim() != "")
+    #set($parts = $rawValue.split(","))
+    , #foreach($p in $parts)
+      '$p.trim()'#if($foreach.hasNext), #end
+    #end
+  #end
+#end
+## Extract and convert string in to object column
+#macro(printTagAsColumnObjects $element $tagName)
+  #set($rawValue = $element.tagValue($tagName))
+  #if($rawValue && $rawValue.trim() != "")
+    #set($parts = $rawValue.split(","))
+    , #foreach($p in $parts)
+    {
+        field: '$p.trim()',
+        header: '$p.trim()',
+        type: ColumnType.TEXT
+    }#if($foreach.hasNext),#end
+    #end
+  #end
+#end
+

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

@@ -0,0 +1,56 @@
+#parse("include/macros.vm")
+import { provideHttpClient, withFetch, withInterceptors } from '@angular/common/http';
+import { ApplicationConfig, importProvidersFrom, InjectionToken } from '@angular/core';
+import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
+import { provideRouter, withEnabledBlockingInitialNavigation, withInMemoryScrolling } from '@angular/router';
+import { providePrimeNG } from 'primeng/config';
+import { ToastModule } from 'primeng/toast';
+import { MessageService } from 'primeng/api';
+import { appRoutes } from './app.routes';
+import { DibaPreset } from '@root/themes/diba.preset';
+import { authInterceptor } from '@core/interceptors/auth.interceptor';
+import { httpResponseInterceptor } from '@core/interceptors/http-response.interceptor';
+
+import { UserInfoRepositoryInterface } from '@core/user-info/domain/user-info.repository.interface';
+export const USER_INFO_REPOSITORY_TOKEN = new InjectionToken<UserInfoRepositoryInterface>('UserInfoRepositoryToken');
+import { UserInfoRepositoryImpl } from '@core/user-info/infrastructure/outbound/user-info.repository.impl';
+
+import { SystemInfoRepositoryInterface } from '@core/system-info/domain/system-info.repository.interface';
+export const SYSTEM_INFO_REPOSITORY_TOKEN = new InjectionToken<SystemInfoRepositoryInterface>('SystemInfoRepositoryToken');
+import { SystemInfoRepositoryImpl } from '@core/system-info/infrastructure/outbound/system-info.repository.impl';
+
+#foreach( $entityM in $model.allEntities )
+import { ${entityM}RepositoryInterface } from '@modules/#kebabCase("${entityM}")/domain/#kebabCase("${entityM}").repository.interface';
+import { ${entityM}RepositoryImpl } from '@modules/#kebabCase("${entityM}")/infrastructure/outbound/#kebabCase("${entityM}").repository.impl';
+#end
+
+#foreach( $entityM in $model.allEntities )
+export const #snakeUpperCase("${entityM}")_REPOSITORY_TOKEN = new InjectionToken<${entityM}RepositoryInterface>('${entityM}RepositoryToken');
+#end
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        provideRouter(appRoutes, withInMemoryScrolling({ anchorScrolling: 'enabled', scrollPositionRestoration: 'enabled' }), withEnabledBlockingInitialNavigation()),
+        provideHttpClient(
+            withFetch(),
+            withInterceptors([
+                authInterceptor,
+                httpResponseInterceptor
+            ])),
+        provideAnimationsAsync(),
+        providePrimeNG({
+            theme: {
+                preset: DibaPreset
+            },
+            translation: {}
+        }),
+        importProvidersFrom(ToastModule),
+        MessageService,
+        
+        { provide: USER_INFO_REPOSITORY_TOKEN, useClass: UserInfoRepositoryImpl } ,// Binding token to class
+        { provide: SYSTEM_INFO_REPOSITORY_TOKEN, useClass: SystemInfoRepositoryImpl } ,// Binding token to class
+#foreach( $entityM in $model.allEntities )
+        { provide: #snakeUpperCase("${entityM}")_REPOSITORY_TOKEN, useClass: ${entityM}RepositoryImpl } #comma( $foreach.hasNext )// Binding token to class
+#end
+    ]
+};

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

@@ -0,0 +1,21 @@
+#parse("include/macros.vm")
+import { Routes } from '@angular/router';
+import {  authCanMatch } from '@core/guards/auth.guard';
+import { LayoutComponent } from '@core/layout/component/layout/layout.component';
+import { NotFoundComponent } from '@core/layout/component/not-found/not-found.component';
+
+export const appRoutes: Routes = [
+    {
+        path: '',
+        canMatch: [authCanMatch],
+        component: LayoutComponent,
+        children: [
+#foreach( $entityM in $model.allEntities )
+            { path: '#kebabCase("${entityM}")', loadChildren: () => import('@modules/#kebabCase("${entityM}")/infrastructure/inbound/pages/#kebabCase("${entityM}").routes') } #comma( $foreach.hasNext )
+
+#end
+        ]
+    },
+    { path: 'pagina-no-trobada', component: NotFoundComponent },
+    { path: '**', redirectTo: '/pagina-no-trobada' }
+];

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/core/layout/component/menu/menu_component_ts.vm

@@ -0,0 +1,30 @@
+#parse("include/macros.vm")
+import { Component } from '@angular/core';
+import { NgForOf } from '@angular/common';
+import { MenuItem } from 'primeng/api';
+import { MenuitemComponent } from '../menuitem/menuitem.component';
+
+@Component({
+    selector: 'app-menu',
+    imports: [MenuitemComponent, NgForOf],
+    templateUrl: './menu.component.html',
+    styleUrl: './menu.component.scss'
+})
+export class MenuComponent {
+    protected model: MenuItem[] = [
+        {
+            label: 'FAM-APP',
+            items: [
+                {
+                    label: 'Inici',
+                    icon: 'pi pi-fw pi-home',
+                    routerLink: ['/']
+                },
+#foreach( $entityM in $model.allEntities )
+                { label: '$entityM', icon: 'pi pi-fw pi-list', routerLink: ['/#kebabCase("${entityM}")'] } #comma( $foreach.hasNext )
+
+#end
+            ]
+        }
+    ];
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/core/layout/component/top-menu/top-menu_component_ts.vm

@@ -0,0 +1,36 @@
+#parse("include/macros.vm")
+import { Component } from '@angular/core';
+import { NgForOf } from '@angular/common';
+import { MenuItem } from 'primeng/api';
+import { MenuitemComponent } from '../menuitem/menuitem.component';
+import { MenubarModule } from 'primeng/menubar';
+import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
+import { faSquareCaretLeft } from '@fortawesome/free-regular-svg-icons';
+import { TopMenuService } from '@core/layout/service/top-menu/top-menu.service';
+import { LayoutService } from '@core/layout/service/layout.service';
+import { MenuModelService } from '@core/layout/service/menu.model.service';
+
+@Component({
+    selector: 'app-top-menu',
+    imports: [MenuitemComponent, NgForOf, MenubarModule, FontAwesomeModule],
+    templateUrl: './top-menu.component.html',
+    styleUrl: './top-menu.component.scss'
+})
+export class TopMenuComponent {
+
+    faSquareCaretLeft = faSquareCaretLeft;
+    protected model: MenuItem[];
+
+    constructor(
+        public layoutService: LayoutService, 
+        private topMenuService: TopMenuService,
+        private menuModelService: MenuModelService
+    ) {
+        this.model = this.menuModelService.model;
+    }
+
+    toggleMenu() {
+        this.topMenuService.toggle();
+        this.layoutService.layoutState.update((prev) => ({ ...prev, overlayMenuActive: true }));
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/core/layout/service/menu_model_service_ts.vm

@@ -0,0 +1,49 @@
+#parse("include/macros.vm")
+import { inject, Injectable } from '@angular/core';
+import { MenuItem } from 'primeng/api';
+import { PrimeNG } from 'primeng/config';
+
+@Injectable({ providedIn: 'root' })
+export class MenuModelService {
+    primengConfig = inject(PrimeNG);
+    translate = (key: string) => (this.primengConfig.translation as Record<string, string>)?.[key] ?? key;
+    readonly model: MenuItem[] = [
+        {
+            label: this.translate('INICI'),
+            icon: 'pi pi-fw pi-home',
+            routerLink: ['/']
+        }, 
+
+#set($DEFAULT_MENU = "MANTENIMENTS")
+#set($menus = [])
+#foreach($e in $model.allEntities)
+  #set($menuName = $e.tagValue("Menu", $DEFAULT_MENU))
+  #if(!$menus.contains($menuName))
+    #set($void = $menus.add($menuName))
+  #end
+#end
+
+#foreach($menu in $menus)
+        {
+            label: this.translate('$menu'),
+            items: [
+#set($first = true)
+#foreach($e in $model.allEntities)
+#set($menuName = $e.tagValue("Menu", $DEFAULT_MENU))
+#if($menuName == $menu)
+#if(!$first),#end
+#set($route = "/#kebabCase('${e.name}')")
+                { 
+                    label: this.translate('${e.name}'),
+                    icon: 'pi pi-fw pi-list',
+                    routerLink: ['/#kebabCase("${e.name}")'] 
+                }
+#set($first = false)
+#end
+#end
+            ]
+        }               #comma($foreach.hasNext)
+
+#end
+  ];
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/create-Xxx_use-case_ts.vm

@@ -0,0 +1,18 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { ${entityName} } from '../domain/#kebabCase("${entityName}").entity';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+
+@Injectable({ providedIn: 'root' })
+export class Create${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(#camelCase("${entityName}"): ${entityName}): Promise<${entityName}> {
+        return await this.repo.create(#camelCase("${entityName}"));
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/create-file-Xxx_use-case_ts.vm

@@ -0,0 +1,17 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+
+@Injectable({ providedIn: 'root' })
+export class CreateFile${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(id: string, file: File, field: string): Promise<void> {
+        return await this.repo.uploadFile(id, file, field);
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/delete-Xxx_use-case_ts.vm

@@ -0,0 +1,17 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+
+@Injectable({ providedIn: 'root' })
+export class Delete${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(id: string): Promise<void> {
+        await this.repo.delete(id);
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/download-Xxx-file_use-case_ts.vm

@@ -0,0 +1,24 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+#if(!$hasFileType)
+#cancel("No File field found in entity")
+#end
+#if(!$hasFileTypeinNAS)
+#cancel("No NAS File field found in entity")
+#end
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+
+@Injectable({ providedIn: 'root' })
+export class Download${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(id: number): Promise<Blob> {
+        return this.repo.downloadFile(id);
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/find-Xxx_use-case_ts.vm

@@ -0,0 +1,18 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { ${entityName} } from '../domain/#kebabCase("${entityName}").entity';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+
+@Injectable({ providedIn: 'root' })
+export class Find${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(id: string): Promise<${entityName} | null> {
+        return this.repo.find(id);
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/search-Xxx_use-case_ts.vm

@@ -0,0 +1,25 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { ${entityName} } from '../domain/#kebabCase("${entityName}").entity';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+import { JsonApiMeta } from '@shared/models/json-api-meta.entity';
+import { Filter } from '@shared/filters/domain/filter.entity';
+
+@Injectable({ providedIn: 'root' })
+export class Search${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(
+        filters?: Filter[], 
+        include?: string[],
+        pagination?: { page: number; limit: number },
+        sort?: string
+    ): Promise<{data: ${entityName}[], meta: JsonApiMeta}> {
+        return this.repo.search(filters, include, pagination, sort);
+    }
+}

package/src/fam-archetype-app/files/tools/cli/TelosysTools/templates/fam-app-templates/main-angular/modules/application/update-Xxx_use-case_ts.vm

@@ -0,0 +1,18 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { Inject, Injectable } from '@angular/core';
+import { ${entityName}RepositoryInterface } from '../domain/#kebabCase("${entityName}").repository.interface';
+import { ${entityName} } from '../domain/#kebabCase("${entityName}").entity';
+import { #snakeUpperCase("${entityName}")_REPOSITORY_TOKEN } from '@root/app.config';
+
+@Injectable({ providedIn: 'root' })
+export class Update${entityName}UseCase {
+    constructor(@Inject(#snakeUpperCase("${entityName}")_REPOSITORY_TOKEN) private repo: ${entityName}RepositoryInterface) {}
+
+    async execute(#camelCase("${entityName}"): ${entityName}): Promise<void> {
+        await this.repo.update(#camelCase("${entityName}"));
+    }
+}

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

@@ -0,0 +1,36 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+#parse("include/macros.vm")
+##---------------------------------------------------
+#foreach( $link in $toOneLinks )
+#if(${link.fieldType}!=${entityName})
+import { ${link.fieldType} } from '../../#kebabCase("$link.fieldType")/domain/#kebabCase("$link.fieldType").entity';
+#end
+#end
+#foreach( $link in $toManyLinks )
+#set( $genericType = "#extractGenericType($link.fieldType)" )
+#if(${link.fieldType}!=$genericType)
+import { $genericType } from '../../#kebabCase("$genericType")/domain/#kebabCase("$genericType").entity';
+#end
+#end
+export interface ${entityName} {
+    id?: string;
+#foreach( $attribute in $entity.nonKeyAttributes )
+#set( $attributeType = $attribute.wrapperType )
+    #snakeLowerCase("$attribute.name")#if($attribute.isNotNull())?#end: #javaTypeToTsType("$attributeType");
+#end
+#foreach( $link in $toOneLinks )
+#if( $velocityCount == 1 )
+    // toOne
+#end
+    #snakeLowerCase("${link.fieldName}"): $link.fieldType;
+#end
+#foreach( $link in $toManyLinks )
+#if( $velocityCount == 1 )
+    // toMany
+#end
+    #snakeLowerCase("${link.fieldName}")?: #extractGenericType("$link.fieldType")[];
+#end
+}

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

@@ -0,0 +1,27 @@
+#parse("include/macros.vm")
+## --------------------------------------------------
+#checkId($entity)
+#parse("include/init_var_entity.vm")
+##---------------------------------------------------
+import { ${entityName} } from './#kebabCase("${entityName}").entity';
+import { JsonApiMeta } from '@shared/models/json-api-meta.entity';
+import { Filter } from '@shared/filters/domain/filter.entity';
+
+export interface ${entityName}RepositoryInterface {
+#if($hasFileType)
+    create(#camelCase("${entityName}"): ${entityName}, opts?: { file?: File; field?: string }): Promise<${entityName}>;
+#else
+    create(#camelCase("${entityName}"): ${entityName}): Promise<${entityName}>;
+#end
+    delete(id: string): Promise<void>;
+#if($hasFileType)
+    update(#camelCase("${entityName}"): ${entityName}, opts?: { file?: File; field?: string }): Promise<void>;
+#else
+    update(#camelCase("${entityName}"): ${entityName}): Promise<void>;
+#end
+    find(id: string): Promise<${entityName} | null>;
+    search(filter?: Filter[], include?: string[], pagination?: { page: number; limit: number }, sort?: string): Promise<{data: ${entityName}[], meta: JsonApiMeta}>;
+#if($hasFileTypeinNAS)    
+    downloadFile(id: number): Promise<Blob>;
+#end
+}