@cerema/cadriciel 1.4.23 → 1.4.26

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

@@ -0,0 +1,886 @@
+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();
+  });
+};