@cerema/cadriciel 1.1.1 → 1.1.2

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

@@ -1,484 +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 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

@@ -1,36 +0,0 @@
-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

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