@cerema/cadriciel 1.0.8 → 1.1.1

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

@@ -0,0 +1,484 @@
+module.exports = (args) => {
+  const hb = require('handlebars');
+  const fs = require('fs');
+  const path = require('path');
+  const { Sequelize } = require('sequelize');
+  const ora = require('ora');
+
+  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);
+    }
+  };
+  const SETUP = fs.readFileSync(`${__dirname}/../../../.uuid`, 'utf-8');
+  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 + '/../../../../api';
+  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 capitalizeFirstLetter = (str) => {
+    if (!str || typeof str !== 'string') {
+      return '';
+    }
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+
+  const ObjectName = capitalizeFirstLetter(args[0]);
+
+  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.RequestBody;
+  import org.springframework.web.bind.annotation.RequestMapping;
+  import org.springframework.web.bind.annotation.RestController;
+  import org.springframework.web.server.ResponseStatusException;
+  
+  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
+  public class ${ObjectName}Controller {
+  
+      @Autowired
+      private ${ObjectName}Service ${args[0]}Service;
+  
+      @Autowired
+      private ${ObjectName}Mapper ${args[0]}Mapper;
+  
+      @GetMapping
+      public List<${ObjectName}DTO> getAll${ObjectName}() {
+          return ${args[0]}Service.getAll${ObjectName}().stream()
+                              .map(${args[0]}Mapper::toDTO)
+                              .collect(Collectors.toList());
+      }
+  
+      @GetMapping("/{id}")
+      public ${ObjectName}DTO get${ObjectName}ById(@PathVariable Long id) {
+          return ${args[0]}Mapper.toDTO(${args[0]}Service.get${ObjectName}ById(id));
+      }
+  
+      @PostMapping
+      public ${ObjectName}DTO createTodo(@RequestBody ${ObjectName}DTO ${args[0]}DTO) {
+          return ${args[0]}Mapper.toDTO(${args[0]}Service.save${ObjectName}(${args[0]}Mapper.toEntity(${args[0]}DTO)));
+      }
+  
+      @DeleteMapping("/{id}")
+      public void delete${ObjectName}(@PathVariable Long id) {
+          ${args[0]}Service.delete${ObjectName}(id);
+      }
+  }`;
+  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;
+
+@Service("${args[0]}Service")
+@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
+public interface ${ObjectName}Service extends GenericService<${ObjectName}, {{DATA_TYPE}}> {
+    
+    List<${ObjectName}> getAll${ObjectName}();
+
+    ${ObjectName} get${ObjectName}ById(Long id);
+
+    ${ObjectName} save${ObjectName}(${ObjectName} ${args[0]});
+
+    void delete${ObjectName}(Long id);
+}`;
+
+  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;
+
+@Repository
+@Transactional(propagation = Propagation.MANDATORY)
+public interface {{ObjectName}}Repository extends GenericRepository<{{ObjectName}}, {{DATA_TYPE}}> {
+}`;
+
+  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 ${commondot}.${schema}.entities.${ObjectName};
+import ${commondot}.${schema}.repositories.${ObjectName}Repository;
+import org.springframework.beans.factory.annotation.Autowired;
+import ${commondot}.${schema}.services.${ObjectName}Service;
+
+import java.util.List;
+
+@Service
+@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
+public class ${ObjectName}ServiceImpl extends GenericServiceImpl<${ObjectName}, {{DATA_TYPE}}> implements ${ObjectName}Service {
+
+    @Autowired
+    private ${ObjectName}Repository ${args[0]}Repository;
+
+    @Override
+    public List<${ObjectName}> getAll${ObjectName}() {
+        return ${args[0]}Repository.findAll();
+    }
+
+    @Override
+    public ${ObjectName} get${ObjectName}ById(Long id) {
+        return ${args[0]}Repository.findById(id).orElse(null);
+    }
+
+    @Override
+    public ${ObjectName} save${ObjectName}(${ObjectName} ${args[0]}) {
+        return ${args[0]}Repository.save(${args[0]});
+    }
+
+    @Override
+    public void delete${ObjectName}(Long id) {
+      ${args[0]}Repository.deleteById(id);
+    }
+}`;
+  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;
+
+@Mapper(componentModel = "spring", uses = {UserMapper.class})
+public interface ${ObjectName}Mapper {
+
+  ${ObjectName}DTO toDTO(${ObjectName} ${args[0]});
+
+  ${ObjectName} toEntity(${ObjectName}DTO dto);`;
+
+  let dto = `package ${commondot}.${schema}.dto;
+
+public class ${ObjectName}DTO extends GenericDTO{`;
+
+  const persistence_dir = path.resolve(
+    `${__dirname}/../../../../api/${schema}-persistance/src/${commondir}/${schema}/repositories`
+  );
+  const metier_dir = path.resolve(
+    `${__dirname}/../../../../api/${schema}-metier/src/${commondir}/${schema}/services`
+  );
+  const metier_impl_dir = path.resolve(
+    `${__dirname}/../../../../api/${schema}-metier/src/${commondir}/${schema}/services/Impl`
+  );
+  const presentation_dir = path.resolve(
+    `${__dirname}/../../../../api/${schema}-presentation/src/${commondir}/${schema}/`
+  );
+
+  const metier_filename =
+    metier_dir + '/' + capitalizeFirstLetter(ObjectName) + 'Service.java';
+  const metier_impl_filename =
+    metier_impl_dir +
+    '/' +
+    capitalizeFirstLetter(ObjectName) +
+    'ServiceImpl.java';
+
+  const Service = hb.compile(service);
+
+  const Repository = hb.compile(repository);
+  const ServiceImpl = hb.compile(service_impl);
+
+  const repository_filename =
+    persistence_dir +
+    '/' +
+    capitalizeFirstLetter(ObjectName) +
+    'Repository.java';
+
+  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/' +
+      capitalizeFirstLetter(ObjectName) +
+      'DTO.java';
+    const mapper_filename =
+      presentation_dir +
+      '/mapper/' +
+      capitalizeFirstLetter(ObjectName) +
+      'Mapper.java';
+    const controller_filename =
+      presentation_dir +
+      '/controllers/' +
+      capitalizeFirstLetter(ObjectName) +
+      'Controller.java';
+
+    if (args[1] == '--remove') {
+      try {
+        fs.unlinkSync(repository_filename);
+        fs.unlinkSync(metier_filename);
+        fs.unlinkSync(metier_impl_filename);
+        fs.unlinkSync(dto_filename);
+        fs.unlinkSync(mapper_filename);
+        fs.unlinkSync(controller_filename);
+      } catch (e) {
+        spinner.fail("Le mapping objet n'existe pas");
+        sequelize.close();
+        return console.log(e);
+      }
+      sequelize.close();
+      return spinner.succeed('Suppression de ' + args[0] + ' effectuée.');
+    }
+
+    let privates = [];
+    let getters = [];
+    let setters = [];
+    let DATA_TYPE = 'Long';
+
+    fs.writeFileSync(
+      repository_filename,
+      Repository({ ObjectName, DATA_TYPE })
+    );
+    fs.writeFileSync(metier_filename, Service({ ObjectName, DATA_TYPE }));
+    fs.writeFileSync(
+      metier_impl_filename,
+      ServiceImpl({ ObjectName, DATA_TYPE })
+    );
+
+    for (let i = 0; i < result.length; i++) {
+      let data_type = mapType(result[i].data_type);
+      if (result[i].field_name == 'id') data_type = 'Long';
+      let fieldName = result[i].field_name;
+      const capitalizedFieldName = capitalizeFirstLetter(fieldName);
+
+      // Generate private field
+      if (result[i].foreign_table_name) {
+        if (result[i].foreign_table_name == 'users') {
+          fieldName = 'User';
+          data_type = fieldName + 'DTO';
+        } else {
+          fieldName = capitalizeFirstLetter(result[i].foreign_table_name);
+          data_type = capitalizeFirstLetter(fieldName) + 'DTO';
+        }
+      }
+
+      const prv = `private ${data_type} ${fieldName};`;
+
+      privates.push(prv);
+
+      // Generate getter
+      const getter = `
+  public ${data_type} get${capitalizedFieldName}() {
+      return ${fieldName};
+  }
+      `;
+      getters.push(getter);
+
+      // Generate setter
+      const setter = `
+  public void set${capitalizedFieldName}(${data_type} ${fieldName}) {
+      this.${fieldName} = ${fieldName};
+  }
+      `;
+      setters.push(setter);
+    }
+    dto +=
+      '\n' +
+      privates.join('\n') +
+      getters.join('\n') +
+      setters.join('\n') +
+      '}';
+
+    fs.writeFileSync(dto_filename, dto);
+    fs.writeFileSync(mapper_filename, mapper + '\n}');
+    fs.writeFileSync(controller_filename, controller);
+
+    spinner.succeed(`/api/${args[0]} a été généré.`);
+    sequelize.close();
+  });
+};

package/aaaa/.cadriciel/bin/gen/component/component.js

@@ -0,0 +1,36 @@
+module.exports = (args) => {
+  const fs = require('fs');
+  const Path = require('path');
+
+  const templates = require('../../lib/templates');
+
+  const mkdir = (path) => {
+    if (!fs.existsSync(path)) fs.mkdirSync(path, { recursive: true });
+  };
+
+  // Supprime le slash initial s'il existe
+  let arg = args[0].startsWith('/') ? args[0].slice(1) : args[0];
+  arg = arg.split('/')[0];
+
+  const pagePath = Path.normalize(
+    __dirname + '/../../../../client/app/components/' + arg
+  );
+  const page = arg.split('/');
+  const name = page[page.length - 1];
+  const nameUpper = name.charAt(0).toUpperCase() + name.slice(1);
+
+  mkdir(pagePath);
+
+  fs.writeFileSync(
+    pagePath + '/' + name + '.component.html',
+    templates.cxHTML({ name: name, nameUpperCase: nameUpper })
+  );
+  fs.writeFileSync(
+    pagePath + '/' + name + '.component.ts',
+    templates.cxTS({ name: name, nameUpperCase: nameUpper })
+  );
+  fs.writeFileSync(
+    pagePath + '/' + name + '.component.scss',
+    templates.cxCSS({ name: name, nameUpperCase: nameUpper })
+  );
+};

package/aaaa/.cadriciel/bin/gen/page/page.js

@@ -0,0 +1,163 @@
+module.exports = (args) => {
+  const fs = require('fs');
+  const Path = require('path');
+
+  const templates = require('../../lib/templates');
+
+  const modifyRoutes = (routes) => {
+    routes.forEach((route) => {
+      if (route.children) {
+        // Move the component into children with empty path
+        route.children.unshift({
+          path: '',
+          component: route.component,
+        });
+        delete route.component;
+
+        // Recursively modify the child routes
+        modifyRoutes(route.children);
+      }
+    });
+  };
+
+  const pathsToJson = (paths) => {
+    const routes = [];
+    const imports = [];
+
+    paths.forEach((path) => {
+      const parts = path.split('/').filter(Boolean); // removes empty strings
+      let currentRoute = routes;
+
+      parts.forEach((part, index) => {
+        // Check if the part is 'root'
+        let componentPathPart = part;
+        if (part === 'root') {
+          part = ''; // Change 'root' to empty string
+        }
+
+        let existingRoute = currentRoute.find((route) => route.path === part);
+
+        if (!existingRoute) {
+          existingRoute = { path: part };
+          currentRoute.push(existingRoute);
+        }
+
+        if (index === parts.length - 1) {
+          existingRoute.component =
+            componentPathPart.charAt(0).toUpperCase() +
+            componentPathPart.slice(1) +
+            'Component';
+          const componentName = existingRoute.component;
+
+          if (!imports.find((imp) => imp.name === componentName)) {
+            // Generate the correct import path
+            const importPath =
+              './' +
+              (path + '/' + componentPathPart + '.component').replace(
+                /^\//,
+                ''
+              );
+            imports.push({
+              name: componentName,
+              path: importPath,
+            });
+          }
+        }
+
+        if (index !== parts.length - 1) {
+          if (!existingRoute.children) {
+            existingRoute.children = [];
+          }
+          currentRoute = existingRoute.children;
+        }
+      });
+    });
+
+    return {
+      imports: imports,
+      routes: routes,
+    };
+  };
+
+  const mkdir = (path) => {
+    if (!fs.existsSync(path)) fs.mkdirSync(path, { recursive: true });
+  };
+
+  // Supprime le slash initial s'il existe
+  const arg = args[0].startsWith('/') ? args[0].slice(1) : args[0];
+
+  try {
+    var routes = require(__dirname +
+      '/../../../../.cadriciel/routes/root.json');
+  } catch (e) {
+    var routes = ['root'];
+    mkdir(__dirname + '/../../../../.cadriciel/routes');
+  }
+
+  if (routes.indexOf(arg) > -1)
+    return console.log('\nERREUR:\nLa page existe déjà\n\n');
+
+  const pagePath = Path.normalize(
+    __dirname + '/../../../../client/app/pages/' + arg
+  );
+  const page = arg.split('/');
+  const name = page[page.length - 1];
+  const nameUpper = name.charAt(0).toUpperCase() + name.slice(1);
+
+  mkdir(pagePath);
+
+  fs.writeFileSync(
+    pagePath + '/' + name + '.component.html',
+    templates.html({ name: name, nameUpperCase: nameUpper })
+  );
+  fs.writeFileSync(
+    pagePath + '/' + name + '.component.ts',
+    templates.ts({ name: name, nameUpperCase: nameUpper })
+  );
+  fs.writeFileSync(
+    pagePath + '/' + name + '.component.scss',
+    templates.scss({ name: name, nameUpperCase: nameUpper })
+  );
+
+  routes.push(arg);
+
+  var path = pathsToJson(routes);
+  modifyRoutes(path.routes);
+
+  const ts = templates.route({ imports: path.imports, routes: path.routes });
+
+  const routePath = Path.normalize(
+    __dirname + '/../../../../client/app/pages/pages-routing.module.ts'
+  );
+
+  fs.writeFileSync(
+    __dirname + '/../../../../.cadriciel/routes/root.json',
+    JSON.stringify(routes)
+  );
+
+  fs.writeFileSync(routePath, ts);
+
+  // menu
+  const menuPath = Path.normalize(
+    __dirname + '/../../../../client/app/menu.json'
+  );
+  var menu = require(menuPath);
+  var pos = -1;
+  for (let i = 0; i < menu.length; i++) {
+    if (menu[i].label == 'PAGES') pos = i;
+  }
+  if (pos == -1) {
+    menu.push({
+      label: 'PAGES',
+      icon: 'pi pi-hashtag',
+      items: [],
+    });
+    pos = menu.length - 1;
+  }
+  menu[pos].items.push({
+    label: nameUpper,
+    icon: 'pi pi-bookmark-fill',
+    routerLink: ['/pages/' + arg],
+  });
+  fs.writeFileSync(menuPath, JSON.stringify(menu, null, 4));
+};