@cerema/cadriciel 1.4.26 → 1.4.29

package/aqtion/.cadriciel/bin/gen/api/api.js

@@ -1,886 +0,0 @@
-module.exports = (args) => {
-  const hb = require('handlebars');
-  const fs = require('fs');
-  const path = require('path');
-  const { Sequelize } = require('sequelize');
-  const ora = require('ora');
-  const toCamelCase = (str) => {
-    return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
-  };
-  const toPascalCase = (str) => {
-    return str.replace(/(^\w|_\w)/g, (g) => g.replace('_', '').toUpperCase());
-  };
-
-  const pgToJavaMapping = {
-    'character varying': 'String',
-    varchar: 'String',
-    text: 'String',
-    character: 'String',
-    char: 'String',
-    bigint: 'Long',
-    smallint: 'Short',
-    integer: 'Integer',
-    int: 'Integer',
-    'double precision': 'Double',
-    real: 'Float',
-    boolean: 'Boolean',
-    bytea: 'byte[]',
-    timestamp: 'Timestamp',
-    'timestamp without time zone': 'Timestamp',
-    'timestamp with time zone': 'OffsetDateTime',
-    date: 'LocalDate',
-    time: 'LocalTime',
-    'time without time zone': 'LocalTime',
-    'time with time zone': 'OffsetTime',
-    numeric: 'BigDecimal',
-    decimal: 'BigDecimal',
-    json: 'String',
-    jsonb: 'String',
-    uuid: 'UUID',
-    cidr: 'String',
-    inet: 'String',
-    macaddr: 'String',
-    macaddr8: 'String',
-    point: 'PGpoint',
-    line: 'String',
-    lseg: 'String',
-    box: 'String',
-    path: 'String',
-    polygon: 'String',
-    circle: 'String',
-    interval: 'Duration',
-    bit: 'BitSet',
-    'bit varying': 'BitSet',
-    varbit: 'BitSet',
-    tsvector: 'String',
-    tsquery: 'String',
-    oid: 'Long',
-    xid: 'Long',
-    cid: 'Long',
-    pg_lsn: 'Long',
-    txid_snapshot: 'String',
-    int2vector: 'String',
-    pg_ddl_command: 'String',
-    void: 'Void',
-    event_trigger: 'String',
-    pg_snapshot: 'String',
-    regproc: 'String',
-    regprocedure: 'String',
-    regoper: 'String',
-    regoperator: 'String',
-    regclass: 'String',
-    regtype: 'String',
-    regrole: 'String',
-    regnamespace: 'String',
-    regconfig: 'String',
-    regdictionary: 'String',
-  };
-
-  function mapType(type) {
-    return pgToJavaMapping[type] || 'String';
-  }
-
-  const getTableComposition = async (schemaName, tb) => {
-    let query = `
-  WITH primary_keys AS (
-      SELECT 
-          kcu.table_name,
-          kcu.column_name
-      FROM 
-          information_schema.table_constraints tc
-      JOIN 
-          information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-      WHERE 
-          tc.constraint_type = 'PRIMARY KEY'
-          AND tc.table_schema = :schemaName
-  ),
-  
-  foreign_keys AS (
-      SELECT
-          kcu.table_name,
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-      FROM
-          information_schema.table_constraints tc
-      JOIN 
-          information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-      JOIN 
-          information_schema.constraint_column_usage ccu 
-          ON tc.constraint_name = ccu.constraint_name
-      WHERE 
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = :schemaName
-  )
-  
-  SELECT 
-      tbl.table_schema,
-      tbl.table_name,
-      a.attname AS field_name,
-      format_type(a.atttypid, a.atttypmod) AS data_type,
-      CASE 
-          WHEN pk.column_name IS NOT NULL THEN 'YES' 
-          ELSE 'NO' 
-      END AS is_primary_key,
-      fk.foreign_table_name,
-      fk.foreign_column_name
-  FROM 
-      information_schema.tables tbl
-  JOIN 
-      pg_attribute a 
-      ON tbl.table_name::regclass = a.attrelid
-  LEFT JOIN 
-      primary_keys pk 
-      ON tbl.table_name = pk.table_name AND a.attname = pk.column_name
-  LEFT JOIN
-      foreign_keys fk
-      ON tbl.table_name = fk.table_name AND a.attname = fk.column_name
-  WHERE 
-      a.attnum > 0 
-      AND NOT a.attisdropped 
-      AND tbl.table_schema = :schemaName
-      AND tbl.table_type = 'BASE TABLE'
-      AND tbl.table_name= :tb
-  ORDER BY 
-      tbl.table_name, 
-      a.attname;
-    `;
-
-    try {
-      const result = await sequelize.query(query, {
-        replacements: { schemaName, tb },
-        type: Sequelize.QueryTypes.SELECT,
-      });
-
-      return result;
-    } catch (error) {
-      console.error('Failed to fetch table composition:', error);
-    }
-  };
-  try {
-    var SETUP = fs.readFileSync(`${__dirname}/../../../.uuid`, 'utf-8');
-  } catch (e) {
-    console.log(
-      chalk.bold('  [ENV] ') +
-        chalk.red(" Votre environnement n'est pas démarré.")
-    );
-    return process.exit(1);
-  }
-  require('dotenv').config({
-    path: `${__dirname}/../../../../docker/${SETUP}/.env`,
-  });
-
-  const uri = `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@localhost:${process.env.POSTGRES_DEV_PORT}/${process.env.POSTGRES_DB}`;
-  const sequelize = new Sequelize(uri, {
-    logging: false,
-  });
-
-  const dir = __dirname + '/../../../../backend';
-  const data_dir = fs.readdirSync(dir);
-  const commondir = 'main/java/fr/cerema/dsi';
-  const commondot = commondir.replace(/\//g, '.').split('main.java.')[1];
-
-  let data = data_dir.find((item) => item.includes('-data'));
-  const schema = data.split('-data')[0];
-
-  if (args.length == 0)
-    return console.log("\nLe nom de l'objet est manquant\n");
-
-  const REPOSITORY_DIR = path.normalize(
-    `${__dirname}/../../../../backend/${schema}-persistance/src/${commondir}/${schema}/repositories`
-  );
-  const SHARED_REPOSITORY_DIR = path.normalize(
-    `${__dirname}/../../../shared/repositories`
-  );
-  try {
-    fs.mkdirSync(SHARED_REPOSITORY_DIR);
-  } catch (e) {}
-
-  try {
-    var INSTALLED_FILES = JSON.parse(
-      fs.readFileSync(
-        `${__dirname}/../../../../shared/api.${args[0]}.cache`,
-        'utf-8'
-      )
-    );
-    for (let i = 0; i < INSTALLED_FILES.length; i++) {
-      try {
-        fs.unlinkSync(INSTALLED_FILES[i]);
-      } catch (e) {}
-    }
-    INSTALLED_FILES = [];
-  } catch (e) {
-    var INSTALLED_FILES = [];
-  }
-
-  const ObjectName = toPascalCase(args[0]);
-  const apiEndPoint = toCamelCase(args[0]);
-
-  const Interface = `
-  import { HttpClient } from '@angular/common/http';
-  import { Injectable } from '@angular/core';
-  import { Observable } from 'rxjs';
-  import { ApplicationConfigService } from 'layout/shared/core/config/application-config.service';
-  import { ${ObjectName}, ${ObjectName}DTO } from 'app/interfaces/${ObjectName}';
-  
-  @Injectable({
-    providedIn: 'root',
-  })
-
-  export class ${ObjectName}Service {
-
-    constructor(
-      private httpClient: HttpClient,
-      private applicationConfigService: ApplicationConfigService
-    ) {}
-  
-    public getAll(): Observable<${ObjectName}[]> {
-      return this.httpClient.get<${ObjectName}[]>(
-        this.applicationConfigService.getEndpointFor('/${apiEndPoint}')
-      );
-    }
-
-    public getById(id: any): Observable<${ObjectName}[]> {
-      return this.httpClient.get<${ObjectName}[]>(
-        this.applicationConfigService.getEndpointFor('/${apiEndPoint}/'+id)
-      );
-    }
-
-    public save(data: ${ObjectName}DTO): Observable<${ObjectName}[]> {
-      return this.httpClient.post<${ObjectName}[]>(
-        this.applicationConfigService.getEndpointFor('/${apiEndPoint}'),
-        data
-      );
-    }
-
-    public patch(id: any, data: ${ObjectName}DTO): Observable<${ObjectName}[]> {
-      return this.httpClient.patch<${ObjectName}[]>(
-        this.applicationConfigService.getEndpointFor('/${apiEndPoint}/'+id),
-        data
-      );
-    }
-
-    public update(data: ${ObjectName}DTO): Observable<${ObjectName}[]> {
-      return this.httpClient.put<${ObjectName}[]>(
-        this.applicationConfigService.getEndpointFor('/${apiEndPoint}/'+data.id),
-        data
-      );
-    }
-
-    public delete(id: any): Observable<${ObjectName}[]> {
-      return this.httpClient.delete<${ObjectName}[]>(
-        this.applicationConfigService.getEndpointFor('/${apiEndPoint}/'+id)
-      );
-    }
-    
-  }`;
-
-  const controller = `package ${commondot}.${schema}.controllers;
-
-  import java.util.List;
-  import java.util.Optional;
-  import java.util.stream.Collectors;
-  
-  import org.springframework.beans.factory.annotation.Autowired;
-  import org.springframework.http.HttpStatus;
-  import org.springframework.web.bind.annotation.CrossOrigin;
-  import org.springframework.web.bind.annotation.DeleteMapping;
-  import org.springframework.web.bind.annotation.GetMapping;
-  import org.springframework.web.bind.annotation.PathVariable;
-  import org.springframework.web.bind.annotation.PostMapping;
-  import org.springframework.web.bind.annotation.PatchMapping;
-  import org.springframework.web.bind.annotation.PutMapping;
-  import org.springframework.web.bind.annotation.RequestBody;
-  import org.springframework.web.bind.annotation.RequestMapping;
-  import org.springframework.web.bind.annotation.RestController;
-  import org.springframework.web.server.ResponseStatusException;
-  import org.springframework.web.bind.annotation.RequestParam;
-  
-  import io.swagger.v3.oas.annotations.security.SecurityRequirement;
-  import io.swagger.v3.oas.annotations.tags.Tag;
-  
-  import ${commondot}.${schema}.services.${ObjectName}Service;
-  import ${commondot}.${schema}.services.UserService;
-  import ${commondot}.${schema}.dto.${ObjectName}DTO;
-  import ${commondot}.${schema}.entities.${ObjectName};
-  import ${commondot}.${schema}.entities.User;
-  
-  import ${commondot}.${schema}.mapper.${ObjectName}Mapper;
-  
-  @Tag(name = "${ObjectName}", description = "${ObjectName} endpoints")
-  @RestController
-  @RequestMapping("/api/${args[0]}")
-  @CrossOrigin
-  @SecurityRequirement(name = "ORION_AUTH")
-  public class ${ObjectName}Controller {
-  
-      @Autowired
-      private ${ObjectName}Service ${args[0]}Service;
-  
-      @Autowired
-      private ${ObjectName}Mapper ${args[0]}Mapper;
-  
-      @GetMapping
-      public List<${ObjectName}DTO> getAll() {
-          return ${args[0]}Service.getAll().stream()
-                              .map(${args[0]}Mapper::toDTO)
-                              .collect(Collectors.toList());
-      }
-  
-      @GetMapping("/{id}")
-      public ${ObjectName}DTO getById(@PathVariable {{DATA_TYPE}} id) {
-          return ${args[0]}Mapper.toDTO(${args[0]}Service.getById(id));
-      }
-  
-      @PostMapping
-      public ${ObjectName}DTO create(@RequestBody ${ObjectName}DTO ${args[0]}DTO) {
-          return ${args[0]}Mapper.toDTO(${args[0]}Service.save(${args[0]}Mapper.toEntity(${args[0]}DTO)));
-      }    
-
-      @PatchMapping("/{id}")
-      public ${ObjectName}DTO update(@PathVariable {{DATA_TYPE}} id, @RequestBody ${ObjectName}DTO ${args[0]}DTO) {
-        ${ObjectName} ${args[0]}Entity = ${args[0]}Mapper.toEntity(${args[0]}DTO);
-        ${ObjectName} updated = ${args[0]}Service.update(id, ${args[0]}Entity);
-        return ${args[0]}Mapper.toDTO(updated);
-      }  
-
-      @PutMapping
-      public ${ObjectName}DTO replace(@RequestBody ${ObjectName}DTO ${args[0]}DTO) {
-      
-          ${ObjectName} ${args[0]}Entity = ${args[0]}Mapper.toEntity(${args[0]}DTO);
-          ${ObjectName} replaced = ${args[0]}Service.save(${args[0]}Entity);
-      
-          return ${args[0]}Mapper.toDTO(replaced);
-      }
-  
-      @DeleteMapping("/{id}")
-      public void delete(@PathVariable {{DATA_TYPE}} id) {
-          ${args[0]}Service.delete(id);
-      }
-
-{{{OTHER_API}}}
-  }`;
-
-  const service = `package ${commondot}.${schema}.services;
-
-import ${commondot}.commons.services.GenericService;
-import ${commondot}.${schema}.entities.${ObjectName};
-
-import java.util.List;
-
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-
-public interface ${ObjectName}Service extends GenericService<${ObjectName}, {{DATA_TYPE}}> {
-    
-    List<${ObjectName}> getAll();
-
-    ${ObjectName} getById({{DATA_TYPE}} id);
-
-    ${ObjectName} save(${ObjectName} ${args[0]});
-
-    ${ObjectName} update({{DATA_TYPE}} id, ${ObjectName} ${args[0]});
-
-    void delete({{DATA_TYPE}} id);
-
-{{{REPOSITORY}}}
-}`;
-
-  const repository = `package ${commondot}.${schema}.repositories;
-
-import ${commondot}.commons.repositories.GenericRepository;
-import ${commondot}.${schema}.entities.{{ObjectName}};
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-
-{{{IMPORTS}}}
-
-@Repository
-@Transactional(propagation = Propagation.MANDATORY)
-public interface {{ObjectName}}Repository extends GenericRepository<{{ObjectName}}, {{DATA_TYPE}}> {
-
-{{{REPOSITORY}}}
-}`;
-
-  const service_impl = `package ${commondot}.${schema}.services.impl;
-
-import ${commondot}.commons.services.GenericServiceImpl;
-
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import ${commondot}.${schema}.entities.${ObjectName};
-import ${commondot}.${schema}.repositories.${ObjectName}Repository;
-import ${commondot}.${schema}.services.${ObjectName}Service;
-
-import java.util.List;
-
-@Service
-@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
-public class ${ObjectName}ServiceImpl extends GenericServiceImpl<${ObjectName}, {{DATA_TYPE}}> implements ${ObjectName}Service {
-
-    @Autowired
-    private ${ObjectName}Repository ${apiEndPoint}Repository;
-
-    @Override
-    public List<${ObjectName}> getAll() {
-        return ${apiEndPoint}Repository.findAll();
-    }
-
-    @Override
-    public ${ObjectName} getById({{DATA_TYPE}} id) {
-        return ${apiEndPoint}Repository.findById(id).orElse(null);
-    }
-
-    @Override
-    public ${ObjectName} save(${ObjectName} ${apiEndPoint}) {
-        return ${apiEndPoint}Repository.save(${apiEndPoint});
-    }
-
-    @Override
-    public void delete({{DATA_TYPE}} id) {
-      ${apiEndPoint}Repository.deleteById(id);
-    }
-
-    @Override
-    public ${ObjectName} update({{DATA_TYPE}} id, ${ObjectName} ${apiEndPoint}) {
-      ${ObjectName} existing${ObjectName} = ${apiEndPoint}Repository.findById(id)
-            .orElseThrow(() -> new RuntimeException("No ${ObjectName} found with id: " + id));
-
-        {{{FIELDS}}}
-
-        return ${apiEndPoint}Repository.save(existing${ObjectName});
-    }
-
-{{{REPOSITORY}}}
-}`;
-
-  let mapper = `package ${commondot}.${schema}.mapper;
-
-import ${commondot}.${schema}.dto.${ObjectName}DTO;
-import ${commondot}.${schema}.entities.${ObjectName};
-import org.mapstruct.Mapper;
-import org.mapstruct.Mapping;
-
-{{{MAPPERS}}}
-public interface ${ObjectName}Mapper {
-
-  ${ObjectName}DTO toDTO(${ObjectName} ${args[0]});
-
-  ${ObjectName} toEntity(${ObjectName}DTO dto);
-  `;
-
-  let dto = `package ${commondot}.${schema}.dto;
-  
-import com.fasterxml.jackson.annotation.JsonProperty;
-import java.io.Serializable;
-`;
-
-  const persistence_dir = path.resolve(
-    `${__dirname}/../../../../backend/${schema}-persistance/src/${commondir}/${schema}/repositories`
-  );
-  const metier_dir = path.resolve(
-    `${__dirname}/../../../../backend/${schema}-metier/src/${commondir}/${schema}/services`
-  );
-  const metier_impl_dir = path.resolve(
-    `${__dirname}/../../../../backend/${schema}-metier/src/${commondir}/${schema}/services/Impl`
-  );
-  const presentation_dir = path.resolve(
-    `${__dirname}/../../../../backend/${schema}-presentation/src/${commondir}/${schema}/`
-  );
-  const metier_filename =
-    metier_dir + '/' + toPascalCase(ObjectName) + 'Service.java';
-  const metier_impl_filename =
-    metier_impl_dir + '/' + toPascalCase(ObjectName) + 'ServiceImpl.java';
-  const repository_filename =
-    persistence_dir + '/' + toPascalCase(ObjectName) + 'Repository.java';
-
-  const Service = hb.compile(service);
-  const Repository = hb.compile(repository);
-  const ServiceImpl = hb.compile(service_impl);
-  const Controller = hb.compile(controller);
-  const Mapper = hb.compile(mapper);
-
-  const spinner = ora("Generation de l'API pour " + args[0]).start();
-  getTableComposition(schema, args[0]).then((result) => {
-    if (result.length == 0) {
-      spinner.fail('La table ' + args[0] + " n'existe pas");
-      return sequelize.close();
-    }
-
-    const dto_filename =
-      presentation_dir + '/dto/' + toPascalCase(ObjectName) + 'DTO.java';
-    const mapper_filename =
-      presentation_dir + '/mapper/' + toPascalCase(ObjectName) + 'Mapper.java';
-    const controller_filename =
-      presentation_dir +
-      '/controllers/' +
-      toPascalCase(ObjectName) +
-      'Controller.java';
-
-    let privates = [];
-    let getters = [];
-    let setters = [];
-    let DATA_TYPE;
-    let FIELDS = [];
-    for (let i = 0; i < result.length; i++) {
-      if (result[i].is_primary_key === 'YES') {
-        DATA_TYPE = mapType(result[i].data_type);
-      }
-    }
-
-    var REPOSITORY_FILENAME =
-      REPOSITORY_DIR + '/' + args[0] + 'Repository.java';
-    var REPOSITORY_SHARED = SHARED_REPOSITORY_DIR + '/' + args[0] + '.json';
-
-    try {
-      var queries = JSON.parse(fs.readFileSync(REPOSITORY_SHARED, 'utf-8'));
-    } catch (e) {
-      var queries = [];
-    }
-
-    function updateRepository(content, jsonData, imports = []) {
-      function extractImports(content) {
-        const importPattern = /import [a-zA-Z0-9.*]+;/g;
-        const matches = content.match(importPattern);
-        return matches || [];
-      }
-      function removeImports(content) {
-        const importPattern = /^import [a-zA-Z0-9.*]+;\s*/gm;
-        return content.replace(importPattern, '');
-      }
-
-      let javaCode = '';
-      for (let i = 0; i < imports.length; i++) {
-        imports[i] = 'import ' + imports[i] + ';';
-      }
-
-      const _import = extractImports(content);
-      imports = [...new Set([..._import, ...imports])];
-
-      content = removeImports(content);
-
-      var code = content.substring(0, content.indexOf('{') + 1);
-
-      for (const item of jsonData) {
-        if (item.label) {
-          javaCode += `  ${item.label}(`;
-          if (item.params && item.params.length > 0) {
-            let firstParam = true;
-            for (const param of item.params) {
-              if (!firstParam) {
-                javaCode += ', ';
-              }
-              if (param.value == 'true' || param.value == 'false') {
-                javaCode += `${param.name} = ${param.value}`;
-              } else javaCode += `${param.name} = "${param.value}"`;
-              firstParam = false;
-            }
-          }
-          javaCode += `)\n`;
-        }
-
-        if (item.fn) {
-          javaCode += `  ${item.fn.return} ${item.fn.name}(`;
-          if (item.fn.args && item.fn.args.length > 0) {
-            for (const arg of item.fn.args) {
-              if (arg.param) {
-                javaCode += `@Param("${arg.param}") `;
-              }
-              javaCode += `${arg.type} ${arg.name}, `;
-            }
-            javaCode = javaCode.slice(0, -2);
-          }
-
-          javaCode += `);\n`;
-        }
-      }
-
-      code = code.split('\n');
-      code.splice(1, 0, ...imports);
-
-      return javaCode;
-    }
-
-    const repositoryContent = Repository({
-      ObjectName,
-      DATA_TYPE,
-      REPOSITORY: '',
-      IMPORTS: '',
-    });
-
-    var javaCode = updateRepository(repositoryContent, queries);
-
-    fs.writeFileSync(
-      repository_filename,
-      Repository({
-        ObjectName,
-        DATA_TYPE,
-        REPOSITORY: javaCode,
-        IMPORTS: [
-          'import java.util.List;',
-          'import org.springframework.data.jpa.repository.Query;',
-        ].join('\n'),
-      })
-    );
-
-    INSTALLED_FILES.push(repository_filename);
-    try {
-      var REPOSITORY_CONTENT = JSON.parse(
-        fs.readFileSync(
-          `${__dirname}/../../../shared/repositories/${apiEndPoint}.json`,
-          'utf-8'
-        )
-      );
-    } catch (e) {
-      var REPOSITORY_CONTENT = [];
-    }
-
-    var REPOSITORY = [];
-    for (let i = 0; i < REPOSITORY_CONTENT.length; i++) {
-      const args = [];
-      for (let j = 0; j < REPOSITORY_CONTENT[i].fn.args.length; j++)
-        args.push(
-          REPOSITORY_CONTENT[i].fn.args[j].type +
-            ' ' +
-            REPOSITORY_CONTENT[i].fn.args[j].name
-        );
-      const cmd = `${REPOSITORY_CONTENT[i].fn.return} ${
-        REPOSITORY_CONTENT[i].fn.name
-      }(${args.join(', ')});`;
-      REPOSITORY.push('    ' + cmd);
-    }
-
-    REPOSITORY = REPOSITORY.join('\n');
-    fs.writeFileSync(
-      metier_filename,
-      Service({ ObjectName, DATA_TYPE, REPOSITORY })
-    );
-    INSTALLED_FILES.push(metier_filename);
-
-    const javaTypeImport = {
-      Date: 'java.util.Date',
-      LocalDate: 'java.time.LocalDate',
-      LocalTime: 'java.time.LocalTime',
-      LocalDateTime: 'java.time.LocalDateTime',
-      OffsetDateTime: 'java.time.OffsetDateTime',
-      ZonedDateTime: 'java.time.ZonedDateTime',
-      Duration: 'java.time.Duration',
-      BigDecimal: 'java.math.BigDecimal',
-      'List<Integer>': 'java.util.List',
-      'List<String>': 'java.util.List',
-      'List<Employees>': 'java.util.List',
-    };
-
-    let imports = [];
-    let Imports = [];
-    let mappn = [];
-    let zmap = require(__dirname + '/../../../shared/' + args[0] + '.json');
-
-    /** prise en compte des clés composites */
-    let primaryKeys = [];
-    let zeromap = false;
-    if (Object.keys(zmap).length == 0) zeromap = true;
-    for (let i = 0; i < result.length; i++) {
-      if (result[i].is_primary_key === 'YES') {
-        primaryKeys.push(mapType(result[i].data_type));
-        if (zeromap === true)
-          zmap[result[i].field_name] = toCamelCase(result[i].field_name);
-      }
-    }
-
-    if (primaryKeys.length > 1) {
-      DATA_TYPE = `${toPascalCase(ObjectName)}Key`;
-      spinner.fail('Composite keys are not supported yet.');
-      process.exit(1);
-    } else if (primaryKeys.length === 1) {
-      DATA_TYPE = primaryKeys[0];
-    } else {
-      spinner.fail("Vous avez besoin d'au moins une clé primaire.");
-      return process.exit(1);
-    }
-
-    for (let i = 0; i < result.length; i++) {
-      let data_type = mapType(result[i].data_type);
-
-      let import_type = javaTypeImport[data_type];
-      if (import_type) {
-        if (imports.indexOf(import_type) == -1) {
-          imports.push(import_type);
-          Imports.push(`import ${import_type};`);
-        }
-      }
-
-      let fieldName = result[i].field_name;
-      const capitalizedFieldName = toPascalCase(fieldName);
-
-      // Generate private field
-      if (result[i].foreign_table_name) {
-        if (result[i].foreign_table_name == 'users') {
-          fieldName = 'User';
-          data_type = fieldName + 'DTO';
-          mappn.push(fieldName + 'Mapper.class');
-        } else {
-          fieldName = toPascalCase(result[i].foreign_table_name);
-          data_type = toPascalCase(fieldName) + 'DTO';
-          mappn.push(
-            toPascalCase(result[i].foreign_table_name) + 'Mapper.class'
-          );
-        }
-      }
-
-      FIELDS.push(`
-        if (${apiEndPoint}.get${toPascalCase(
-        zmap[result[i].field_name]
-      )}() != null) {
-          existing${ObjectName}.set${toPascalCase(
-        zmap[result[i].field_name]
-      )}(${apiEndPoint}.get${toPascalCase(zmap[result[i].field_name])}());
-        };
-        `);
-      const prv = `  private ${data_type} ${toCamelCase(
-        zmap[result[i].field_name]
-      )};`;
-
-      privates.push(prv);
-
-      // Generate getter
-      const getter = `
-  public ${data_type} get${toPascalCase(zmap[result[i].field_name])}() {
-      return ${toCamelCase(zmap[result[i].field_name])};
-  }
-      `;
-      getters.push(getter);
-
-      // Generate setter
-      const setter = `
-  public void set${toPascalCase(
-    zmap[result[i].field_name]
-  )}(${data_type} ${toCamelCase(zmap[result[i].field_name])}) {
-      this.${toCamelCase(zmap[result[i].field_name])} = ${toCamelCase(
-        zmap[result[i].field_name]
-      )};
-  }
-      `;
-      setters.push(setter);
-    }
-
-    try {
-      var REPOSITORY_CONTENT = JSON.parse(
-        fs.readFileSync(
-          `${__dirname}/../../../shared/repositories/${apiEndPoint}.json`,
-          'utf-8'
-        )
-      );
-    } catch (e) {
-      var REPOSITORY_CONTENT = [];
-    }
-
-    var REPOSITORY = [];
-    for (let i = 0; i < REPOSITORY_CONTENT.length; i++) {
-      const args = [];
-      for (let j = 0; j < REPOSITORY_CONTENT[i].fn.args.length; j++)
-        args.push(
-          REPOSITORY_CONTENT[i].fn.args[j].type +
-            ' ' +
-            REPOSITORY_CONTENT[i].fn.args[j].name
-        );
-      REPOSITORY.push('    @Override');
-      REPOSITORY.push(
-        `    public ${REPOSITORY_CONTENT[i].fn.return} ${
-          REPOSITORY_CONTENT[i].fn.name
-        }(${args.join(', ')}){`
-      );
-      REPOSITORY.push(
-        `        return employeesRepository.ListEmployeesByTerritories(RegionID);`
-      );
-      REPOSITORY.push(`    }\n`);
-    }
-    REPOSITORY = REPOSITORY.join('\n');
-    fs.writeFileSync(
-      metier_impl_filename,
-      ServiceImpl({
-        FIELDS: FIELDS.join('\n'),
-        ObjectName,
-        DATA_TYPE,
-        REPOSITORY,
-      })
-    );
-    INSTALLED_FILES.push(metier_impl_filename);
-
-    dto +=
-      Imports.join('\n') +
-      '\n\n' +
-      `public class ${ObjectName}DTO implements Serializable{` +
-      '\n\n' +
-      privates.join('\n') +
-      '\n' +
-      getters.join('') +
-      setters.join('\n') +
-      '\n}';
-
-    fs.writeFileSync(dto_filename, dto);
-    INSTALLED_FILES.push(dto_filename);
-    let mapz = '';
-    if (mappn.length > 0)
-      mapz = `@Mapper(componentModel = "spring", uses = {${mappn.join(', ')}})`;
-    else mapz = `@Mapper(componentModel = "spring")`;
-
-    fs.writeFileSync(
-      mapper_filename,
-      Mapper({
-        MAPPERS: mapz,
-        IMPORTS: Imports.join('\n'),
-      }) + '\n}'
-    );
-    INSTALLED_FILES.push(mapper_filename);
-
-    var OTHER_API = [];
-
-    for (let i = 0; i < queries.length; i++) {
-      const args = queries[i].fn.args;
-      var ReqParams = [];
-      var ReqArgs = [];
-      for (let j = 0; j < args.length; j++) {
-        ReqParams.push(`@RequestParam ${args[j].type} ${args[j].name}`);
-        ReqArgs.push(args[j].name);
-      }
-      const cmd = `
-      @GetMapping("/${queries[i].fn.name}")
-      public List<${ObjectName}DTO> ${queries[i].fn.name}(${ReqParams}) {
-        return employeesService.${queries[i].fn.name}(${ReqArgs})
-                                .stream()
-                                .map(${apiEndPoint}Mapper::toDTO)
-                                .collect(Collectors.toList());
-      }
-      `;
-      OTHER_API.push(cmd);
-    }
-
-    OTHER_API = OTHER_API.join('\n');
-
-    fs.writeFileSync(
-      controller_filename,
-      Controller({ DATA_TYPE: DATA_TYPE, OTHER_API: OTHER_API })
-    );
-    INSTALLED_FILES.push(controller_filename);
-
-    const iface_filename = `${__dirname}/../../../../frontend/app/services/${apiEndPoint}.service.ts`;
-
-    fs.writeFileSync(iface_filename, Interface);
-    INSTALLED_FILES.push(iface_filename);
-
-    spinner.succeed(`/api/${apiEndPoint} a été généré.`);
-    fs.writeFileSync(
-      __dirname + '/../../../watcher/pid',
-      new Date().toISOString()
-    );
-    sequelize.close();
-  });
-};