@cerema/cadriciel 1.0.8 → 1.1.1

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

@@ -0,0 +1,172 @@
+module.exports = (args) => {
+  const hb = require('handlebars');
+  const fs = require('fs');
+  const xml2js = require('xml2js');
+  const path = require('path');
+  const ora = require('ora');
+  const prompts = require('prompts');
+  const dir = __dirname + '/../../../../api';
+  const data_dir = fs.readdirSync(dir);
+  const Jimp = require('jimp');
+  const commondir = 'main/java/fr/cerema/dsi';
+  const commondot = commondir.replace(/\//g, '.').split('main.java.')[1];
+  const capitalizeFirstLetter = (str) => {
+    if (!str || typeof str !== 'string') {
+      return '';
+    }
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+  let data = data_dir.find((item) => item.includes('-data'));
+  const schema = data.split('-data')[0];
+  const presentation_dir = path.resolve(
+    `${__dirname}/../../../../api/${schema}-presentation/src/${commondir}/${schema}/`
+  );
+  const configSwagger = fs.readFileSync(
+    __dirname + '/../../templates/java/config.java',
+    'utf-8'
+  );
+
+  const restartIt = async () => {
+    console.log('xxxx');
+    const response = await prompts({
+      type: 'confirm',
+      name: 'value',
+      message: 'Redémarrage du service API ?',
+    });
+
+    if (response.value) {
+      const spinner = ora('Redémarrage du service API').start();
+      const { exec } = require('child_process');
+      exec('yarn restart api', (err, stdout, stderr) => {
+        if (err) {
+          console.error(err);
+          return;
+        }
+        spinner.succeed('Service API redémarré !');
+      });
+    }
+  };
+
+  async function createBanner(imagePath, titleText, cb) {
+    const spinner = ora('Création de la bannière').start();
+    const [image, fontWhite, fontBlack] = await Promise.all([
+      Jimp.read(imagePath),
+      Jimp.loadFont(Jimp.FONT_SANS_128_WHITE), // Police blanche de taille 128
+      Jimp.loadFont(Jimp.FONT_SANS_128_BLACK), // Police noire de taille 128
+    ]);
+
+    const bannerWidth = 1000;
+    const bannerHeight = 192;
+
+    image.resize(Jimp.AUTO, bannerHeight);
+    const banner = new Jimp(bannerWidth, bannerHeight, 0x00000000); // 0x00000000 est transparent
+    banner.composite(image, 0, 0);
+    const textWidth = bannerWidth - image.bitmap.width;
+    const spacing = 30;
+    banner.print(
+      fontBlack,
+      image.bitmap.width + spacing + 2,
+      bannerHeight / 2 -
+        Jimp.measureTextHeight(fontBlack, titleText, textWidth) / 2 +
+        2,
+      {
+        text: titleText,
+        alignmentX: Jimp.HORIZONTAL_ALIGN_LEFT,
+        alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE,
+        width: textWidth - spacing,
+      }
+    );
+    banner.print(
+      fontBlack,
+      image.bitmap.width + spacing + 2,
+      bannerHeight / 2 -
+        Jimp.measureTextHeight(fontBlack, titleText, textWidth) / 2 +
+        3,
+      {
+        text: titleText,
+        alignmentX: Jimp.HORIZONTAL_ALIGN_LEFT,
+        alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE,
+        width: textWidth - spacing,
+      }
+    );
+
+    banner.print(
+      fontWhite,
+      image.bitmap.width + spacing,
+      bannerHeight / 2 -
+        Jimp.measureTextHeight(fontWhite, titleText, textWidth) / 2,
+      {
+        text: titleText,
+        alignmentX: Jimp.HORIZONTAL_ALIGN_LEFT,
+        alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE,
+        width: textWidth - spacing,
+      }
+    );
+    fs.copyFileSync(
+      __dirname + '/../../../../logo.png',
+      __dirname + '/../../../../client/assets/images/logo_title.png'
+    );
+    banner.write(
+      __dirname + '/../../../../client/assets/images/logo_title.png',
+      (err) => {
+        if (err) throw err;
+        spinner.succeed('Bannière créée !');
+        cb();
+      }
+    );
+  }
+  const config_swagger_filename =
+    presentation_dir + '/config/WebConfiguration.java';
+  const ConfigSwagger = hb.compile(configSwagger);
+  const pkg = require('../../../../package.json');
+  const namespace = commondot + '.' + schema;
+  const packageName = pkg.name;
+  const packageDescription = pkg.description;
+  const packageVersion = pkg.version;
+  createBanner(
+    __dirname + '/../../../../logo.png',
+    capitalizeFirstLetter(schema),
+    () => {
+      const spinner = ora(
+        'Création du fichier de configuration Swagger'
+      ).start();
+      fs.writeFileSync(
+        config_swagger_filename,
+        ConfigSwagger({
+          namespace,
+          packageName,
+          packageDescription,
+          packageVersion,
+        })
+      );
+      spinner.succeed('Fichier de configuration Swagger créé !');
+      const spin = ora('Synchronisation du pom.xml').start();
+      fs.readFile(
+        __dirname + '/../../../../pom.xml',
+        'utf8',
+        (err, xmlData) => {
+          if (err) throw err;
+
+          xml2js.parseString(xmlData, async (err, result) => {
+            if (err) throw err;
+
+            result.project.artifactId[0] = packageName;
+            result.project.version[0] = packageVersion;
+            if (!result.project.description) {
+              result.project.description = [];
+            }
+            result.project.description[0] = packageDescription;
+
+            const builder = new xml2js.Builder();
+            const updatedXml = builder.buildObject(result);
+
+            fs.writeFileSync(__dirname + '/../../../../pom.xml', updatedXml);
+            spin.succeed('pom.xml synchronisé !');
+            console.log(' ');
+            await restartIt();
+          });
+        }
+      );
+    }
+  );
+};

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

@@ -0,0 +1,92 @@
+module.exports = (args) => {
+  require('dotenv').config();
+  const fs = require('fs');
+  const Path = require('path');
+  const prompts = require('prompts');
+  const { OpenAI } = require('openai');
+  const ora = require('ora');
+  const path = require('path');
+  const Sequelize = require('sequelize');
+
+  var SETUP = fs.readFileSync(`${__dirname}/../../../.uuid`, 'utf-8');
+  let envContent;
+  const dockerPath = path.resolve(__dirname, `../../../../docker/${SETUP}`);
+  require('dotenv').config({ path: dockerPath + '/.env' });
+
+  const uri = `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@localhost:${process.env.POSTGRES_DEV_PORT}/${process.env.POSTGRES_DB}`;
+
+  const openai = new OpenAI({
+    apiKey: process.env.OPENAI_API_KEY,
+  });
+
+  function extractSQLQueries(text) {
+    const regex = /CREATE TABLE .*?;/gs;
+    return text.match(regex) || [];
+  }
+
+  const replacePrimaryKeys = (sql) => {
+    // Remplacer PRIMARY KEY
+    sql = sql.replace(/(\w+)_id SERIAL PRIMARY KEY/g, 'id SERIAL PRIMARY KEY');
+
+    // Remplacer les références
+    const referenceRegex = /REFERENCES (\w+) \((\w+)_id\)/g;
+    sql = sql.replace(referenceRegex, 'REFERENCES $1 (id)');
+
+    // Remplacer les autres occurrences de _id
+    sql = sql.replace(/(\w+)_id/g, '$1');
+
+    return sql;
+  };
+
+  async function q() {
+    const response = await prompts({
+      type: 'text',
+      name: 'content',
+      message: 'Décrivez la structure de votre base de données',
+    });
+
+    const completion = await openai.chat.completions.create({
+      messages: [
+        {
+          role: 'assistant',
+          content:
+            'write postgres SQL create table with field name escaped and automatically add field id as serial primary key : ' +
+            response.content,
+        },
+      ],
+      model: 'gpt-3.5-turbo',
+    });
+    let SQL = completion.choices[0].message.content;
+    SQL = extractSQLQueries(SQL);
+    SQL = replacePrimaryKeys(SQL.join('\n'));
+    const response2 = await prompts({
+      type: 'confirm',
+      name: 'confirm',
+      message:
+        'Voici votre requête :\n' +
+        SQL +
+        "\nVoulez vous que je l'éxécute sur votre instance postgres ?",
+    });
+    if (response2.confirm) {
+      const spinner = ora('Génération de votre requête SQL...').start();
+      const sequelize = new Sequelize(uri, {
+        logging: false,
+      });
+      sequelize
+        .query(SQL)
+        .then((res) => {
+          spinner.succeed(
+            '👍 Votre requête SQL a bien été éxécutée sur votre instance postgres.'
+          );
+          sequelize.close();
+        })
+        .catch((err) => {
+          spinner.fail('KO');
+          console.log('----');
+          console.log(err.message);
+          console.log('----');
+        });
+    }
+  }
+  q();
+};

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

@@ -0,0 +1,18 @@
+module.exports = (args) => {
+  const fs = require('fs');
+  const Path = require('path');
+
+  const templates = require('../../lib/templates');
+  // Supprime le slash initial s'il existe
+  const arg = args[0].startsWith('/') ? args[0].slice(1) : args[0];
+  const servicePath = Path.normalize(
+    __dirname + '/../../../../client/app/services/' + arg + '.service.ts'
+  );
+  const page = arg.split('/');
+  const name = page[page.length - 1];
+  const nameUpper = name.charAt(0).toUpperCase() + name.slice(1);
+  fs.writeFileSync(
+    servicePath,
+    templates.service({ name: name, nameUpperCase: nameUpper })
+  );
+};

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

@@ -0,0 +1,19 @@
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const hb = require('handlebars');
+const args = process.argv.slice(2);
+
+if (args[0] == 'p') args[0] = 'page';
+if (args[0] == 'c') args[0] = 'component';
+if (args[0] == 's') args[0] = 'service';
+if (args[0] == 'a') args[0] = 'api';
+if (args[0] == 'q') args[0] = 'query';
+if (args[0] == 'a') args[0] = 'api';
+
+try {
+  require(__dirname + '/gen/' + args[0] + '/' + args[0])(args.slice(1));
+} catch (e) {
+  console.log(e);
+  console.log("*** Cette commande n'existe pas ***");
+}

package/aaaa/.cadriciel/bin/lib/convert.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const Handlebars = require('handlebars');
+const prettier = require('prettier');
+
+const emptyModule = {
+  imports: [
+    [['NgModule'], '@angular/core'],
+    [['CommonModule'], '@angular/common'],
+    [['TranslateModule'], '@ngx-translate/core'],
+  ],
+  module: {
+    exports: [],
+    providers: ['MessageService'],
+    declarations: [],
+    imports: [],
+  },
+};
+
+const toJSON = (path) => {
+  const code = fs.readFileSync(path, 'utf8');
+
+  let jsonOutput = {
+    imports: [],
+    module: {
+      exports: [],
+      providers: [],
+      declarations: [],
+      imports: [],
+    },
+  };
+
+  // Handle imports
+  const importRegex = /import {(.+?)} from ['"](.+?)['"]/g;
+  let match;
+  while ((match = importRegex.exec(code)) !== null) {
+    const itemsList = match[1]
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean);
+    const path = match[2];
+    jsonOutput.imports.push([itemsList, path]);
+  }
+
+  // Handle NgModule properties
+  ['providers', 'declarations', 'imports'].forEach((prop) => {
+    const propRegex = new RegExp(`${prop}: \\[([\\s\\S]*?)\\],`);
+    const match = propRegex.exec(code);
+    if (match) {
+      jsonOutput.module[prop] = match[1]
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    }
+  });
+  return jsonOutput;
+};
+
+const toModule = async (path) => {
+  try {
+    const json = JSON.parse(fs.readFileSync(path, 'utf8'));
+  } catch (e) {
+    const json = emptyModule;
+  }
+
+  const importTemplate = "import { {{this.[0].[0]}} } from '{{this.[1]}}';\n";
+  const compiledImportTemplate = Handlebars.compile(importTemplate);
+  let importStatements = json.imports.map(compiledImportTemplate).join('');
+
+  const moduleTemplate = `
+@NgModule({
+  exports: [{{module.exports}}],
+  providers: [{{module.providers}}],
+  declarations: [{{module.declarations}}],
+  imports: [{{module.imports}}],
+})
+export class MyModule {}
+`;
+
+  let compiledModuleTemplate = Handlebars.compile(moduleTemplate);
+  let moduleStatement = compiledModuleTemplate(json);
+
+  let result = importStatements + moduleStatement;
+
+  let moduleFileContent = await prettier.format(result, {
+    parser: 'typescript',
+  });
+
+  return moduleFileContent;
+};
+
+module.exports = {
+  toJSON,
+  toModule,
+};

package/aaaa/.cadriciel/bin/lib/global.js

@@ -0,0 +1,140 @@
+const _ = require('lodash');
+const fs = require('fs');
+
+const queryData = (data, params, fields) => {
+  let results = data;
+
+  // Filter by parameters
+  if (params) {
+    results = results.filter((item) => {
+      return Object.keys(params).every((key) => {
+        return item[key] === params[key];
+      });
+    });
+  }
+
+  // Select fields
+  if (fields) {
+    results = results.map((item) => {
+      const selected = {};
+      fields.forEach((field) => {
+        selected[field] = item[field];
+      });
+      return selected;
+    });
+  }
+
+  return results;
+};
+
+const dbTypes = (type) => {
+  if (type === 'bool') type = 'boolean';
+  else if (type === 'text') type = 'text';
+  else if (type === 'string') type = 'varchar(255)';
+  else if (type === 'int') type = 'integer';
+  else if (type === 'bigint') type = 'bigint';
+  else if (type === 'smallint') type = 'smallint';
+  else if (type === 'decimal') type = 'decimal';
+  else if (type === 'numeric') type = 'numeric';
+  else if (type === 'real') type = 'real';
+  else if (type === 'double') type = 'double precision';
+  else if (type === 'date') type = 'date';
+  else if (type === 'time') type = 'time';
+  else if (type === 'timestamp') type = 'timestamp';
+  else if (type === 'timestamptz') type = 'timestamp with time zone';
+  else if (type === 'interval') type = 'interval';
+  else if (type === 'json') type = 'json';
+  else if (type === 'jsonb') type = 'jsonb';
+  else if (type === 'uuid') type = 'uuid';
+  else if (type === 'geography') type = 'geography';
+  else if (type === 'point') type = 'point';
+  else if (type === 'line') type = 'line';
+  else if (type === 'lseg') type = 'lseg';
+  else if (type === 'box') type = 'box';
+  else if (type === 'path') type = 'path';
+  else if (type === 'polygon') type = 'polygon';
+  else if (type === 'circle') type = 'circle';
+  return type;
+};
+
+const compareArrays = (oldArray, newArray) => {
+  const created = [];
+  const updated = [];
+  const deleted = [];
+
+  // Compare objects in the new array with the old array
+  for (const newObj of newArray) {
+    const matchingObj = oldArray.find((oldObj) => oldObj.id === newObj.id);
+
+    if (matchingObj) {
+      // Object exists in both arrays, check for updates
+      const updatedProperties = {};
+      let hasUpdates = false;
+
+      for (const key in newObj) {
+        if (!_.isEqual(newObj[key], matchingObj[key])) {
+          updatedProperties[key] = {
+            from: matchingObj[key],
+            to: newObj[key],
+          };
+          hasUpdates = true;
+        }
+      }
+
+      if (hasUpdates) {
+        const updateInfo = {
+          id: newObj.id,
+          name: matchingObj.name,
+          schema: matchingObj.schema,
+          updatedProperties,
+        };
+
+        updated.push(updateInfo);
+      }
+    } else {
+      // Object doesn't exist in the old array, it's a new object
+      created.push(newObj);
+    }
+  }
+
+  // Find deleted objects by comparing IDs
+  for (const oldObj of oldArray) {
+    const matchingObj = newArray.find((newObj) => oldObj.id === newObj.id);
+
+    if (!matchingObj) {
+      // Object doesn't exist in the new array, it's deleted
+      deleted.push(oldObj);
+    }
+  }
+
+  return { created, updated, deleted };
+};
+
+const compareConstraintsArrays = (oldArray, newArray) => {
+  const created = _.differenceWith(newArray, oldArray, _.isEqual);
+  const deleted = _.differenceWith(oldArray, newArray, _.isEqual);
+  const commonItems = _.intersectionWith(
+    newArray,
+    oldArray,
+    (newItem, oldItem) => newItem.constraint_name === oldItem.constraint_name
+  );
+  const updated = commonItems.filter((newItem) => {
+    const oldItem = oldArray.find(
+      (i) => i.constraint_name === newItem.constraint_name
+    );
+    return !_.isEqual(newItem, oldItem);
+  });
+
+  return {
+    created,
+    updated,
+    deleted,
+  };
+};
+
+module.exports = {
+  queryData,
+  dbTypes,
+  compareArrays,
+  compareConstraintsArrays,
+};

package/aaaa/.cadriciel/bin/lib/templates.js

@@ -0,0 +1,48 @@
+const hb = require('handlebars');
+const fs = require('fs');
+/** templates */
+const route = hb.compile(
+  fs.readFileSync(__dirname + '/../templates/routing.module.ts', 'utf-8')
+);
+const html = hb.compile(
+  fs.readFileSync(__dirname + '/../templates/{{name}}.component.html', 'utf8')
+);
+const scss = hb.compile(
+  fs.readFileSync(__dirname + '/../templates/{{name}}.component.scss', 'utf8')
+);
+const ts = hb.compile(
+  fs.readFileSync(__dirname + '/../templates/{{name}}.component.ts', 'utf8')
+);
+const service = hb.compile(
+  fs.readFileSync(__dirname + '/../templates/{{name}}.service.ts', 'utf8')
+);
+
+const cxHTML = hb.compile(
+  fs.readFileSync(
+    __dirname + '/../templates/components/{{name}}.component.html',
+    'utf8'
+  )
+);
+const cxCSS = hb.compile(
+  fs.readFileSync(
+    __dirname + '/../templates/components/{{name}}.component.scss',
+    'utf8'
+  )
+);
+const cxTS = hb.compile(
+  fs.readFileSync(
+    __dirname + '/../templates/components/{{name}}.component.ts',
+    'utf8'
+  )
+);
+
+module.exports = {
+  route,
+  html,
+  scss,
+  ts,
+  service,
+  cxTS,
+  cxCSS,
+  cxHTML,
+};

package/aaaa/.cadriciel/bin/lib/utils.js

@@ -0,0 +1,76 @@
+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,
+  };
+};
+
+module.exports = {
+  modifyRoutes,
+  pathsToJson,
+};

package/aaaa/.cadriciel/bin/logs.js

@@ -0,0 +1,34 @@
+const serviceName = process.argv[process.argv.length - 1];
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+var SETUP = fs.readFileSync(`${__dirname}/../.uuid`, 'utf-8').split('\n')[0];
+
+const streamDockerComposeLogs = (serviceName) => {
+  const dockerComposeDir = path.resolve(
+    path.join(__dirname + '/../../docker', SETUP)
+  );
+
+  const dockerComposeLogs = spawn(
+    'docker-compose',
+    ['logs', '-f', serviceName],
+    {
+      cwd: dockerComposeDir,
+    }
+  );
+
+  dockerComposeLogs.stdout.on('data', (data) => {
+    console.log(`${data}`);
+  });
+
+  dockerComposeLogs.stderr.on('data', (data) => {
+    console.error(`${data}`);
+  });
+
+  dockerComposeLogs.on('close', (code) => {
+    console.log(`exited.`);
+  });
+};
+
+streamDockerComposeLogs(serviceName);