@centreon/js-config 24.4.31 → 24.5.0

package/cypress/component/commands.tsx

@@ -62,6 +62,7 @@ interface Query {
 
 export interface InterceptAPIRequestProps<T> {
   alias: string;
+  delay?: number;
   method: Method;
   path: string;
   query?: Query;
@@ -77,7 +78,8 @@ Cypress.Commands.add(
     response,
     alias,
     query,
-    statusCode = 200
+    statusCode = 200,
+    delay = 500
   }: InterceptAPIRequestProps<T>): void => {
     cy.interceptRequest(
       method,
@@ -86,14 +88,14 @@ Cypress.Commands.add(
         const getQuery = req?.url?.searchParams?.get(query?.name);
         if (query && equals(query.value, getQuery)) {
           return res(
-            ctx.delay(500),
+            ctx.delay(delay),
             ctx.json(response),
             ctx.status(statusCode)
           );
         }
         if (!getQuery && isNil(query)) {
           return res(
-            ctx.delay(500),
+            ctx.delay(delay),
             ctx.json(response),
             ctx.status(statusCode)
           );

package/cypress/e2e/commands/configuration.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 
+import { Action } from 'e2e/features/ACLs/commands';
+
 const apiBase = '/centreon/api';
 const apiActionV1 = `${apiBase}/index.php`;
 
@@ -496,9 +498,172 @@ Cypress.Commands.add(
   }
 );
 
+interface ACLGroup {
+  alias?: string | null;
+  contacts?: string[];
+  contactGroups?: string[];
+  name: string;
+}
+
+Cypress.Commands.add(
+  'addACLGroup',
+  ({
+    alias = null,
+    contacts = [],
+    contactGroups = [],
+    name
+  }: ACLGroup): Cypress.Chainable => {
+    const ACLGroupALias = alias === null ? name : alias;
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'ACLGROUP',
+          values: `${name};${ACLGroupALias}`
+        }
+      })
+      .then(() => {
+        if (contacts) {
+          contacts.map((contact) => {
+            cy.executeActionViaClapi({
+              bodyContent: {
+                action: 'ADDCONTACT',
+                object: 'ACLGROUP',
+                values: `${name};${contact}`
+              }
+            });
+          });
+        }
+        if (contactGroups) {
+          contactGroups.map((contactGroup) => {
+            cy.executeActionViaClapi({
+              bodyContent: {
+                action: 'ADDCONTACTGROUP',
+                object: 'ACLGROUP',
+                values: `${name};${contactGroup}`
+              }
+            });
+          });
+        }
+      });
+  }
+);
+
+interface ACLMenu {
+  name: string;
+  rule?: string[];
+  alias?: string | null;
+  includeChildren?: boolean;
+  readOnly?: boolean;
+}
+
+Cypress.Commands.add(
+  'addACLMenu',
+  ({
+    name,
+    rule = [],
+    alias = null,
+    includeChildren = true,
+    readOnly = false
+  }: ACLMenu): Cypress.Chainable => {
+    const ACLMenuAlias = alias === null ? name : alias;
+    const action = readOnly ? 'GRANTRO' : 'GRANTRW';
+    const children = includeChildren ? '1' : '0';
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'ACLMENU',
+          values: `${name};${ACLMenuAlias}`
+        }
+      })
+      .then(() => {
+        if (rule.length == 0) {
+          return cy.wrap(null);
+        }
+
+        let ruleCommand = '';
+        rule.map((rulePage, index) => {
+          ruleCommand += rulePage + (index == rule.length - 1 ? '' : ';');
+        });
+        cy.executeActionViaClapi({
+          bodyContent: {
+            action: action,
+            object: 'ACLMENU',
+            values: `${name};${children};${ruleCommand}`
+          }
+        });
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ACLAction {
+  name: string;
+  description: string;
+  actions?: Action[];
+}
+
+Cypress.Commands.add(
+  'addACLAction',
+  ({ name, description, actions = [] }: ACLAction): Cypress.Chainable => {
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'ACLACTION',
+          values: `${name};${description}`
+        }
+      })
+      .then(() => {
+        if (actions.length == 0) {
+          return cy.wrap(null);
+        }
+
+        let actionCommand = '';
+        actions.map((action, index) => {
+          actionCommand += action + (index == actions.length - 1 ? '' : '|');
+        });
+        cy.executeActionViaClapi({
+          bodyContent: {
+            action: 'GRANT',
+            object: 'ACLACTION',
+            values: `${name};${actionCommand}`
+          }
+        });
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ACLResource {
+  name: string;
+  alias?: string | null;
+}
+
+Cypress.Commands.add(
+  'addACLResource',
+  ({ name, alias = null }: ACLResource): Cypress.Chainable => {
+    const ACLResourcesAlias = alias === null ? name : alias;
+    return cy.executeActionViaClapi({
+      bodyContent: {
+        action: 'ADD',
+        object: 'ACLRESOURCE',
+        values: `${name};${ACLResourcesAlias}`
+      }
+    });
+  }
+);
+
 declare global {
   namespace Cypress {
     interface Chainable {
+      addACLAction: (props: ACLAction) => Cypress.Chainable;
+      addACLGroup: (props: ACLGroup) => Cypress.Chainable;
+      addACLMenu: (props: ACLMenu) => Cypress.Chainable;
+      addACLResource: (props: ACLResource) => Cypress.Chainable;
       addCheckCommand: (props: CheckCommand) => Cypress.Chainable;
       addContact: (props: Contact) => Cypress.Chainable;
       addContactGroup: (props: ContactGroup) => Cypress.Chainable;

package/cypress/e2e/configuration.ts

@@ -59,7 +59,7 @@ export default ({
     },
     env: {
       ...env,
-      DATABASE_IMAGE: 'bitnami/mariadb:10.5',
+      DATABASE_IMAGE: 'bitnami/mariadb:10.11',
       OPENID_IMAGE_VERSION: process.env.MAJOR || '24.04',
       SAML_IMAGE_VERSION: process.env.MAJOR || '24.04',
       WEB_IMAGE_OS: 'alma9',

package/cypress/e2e/tasks.ts

@@ -106,7 +106,7 @@ export default (on: Cypress.PluginEvents): void => {
       const { exitCode, output } = await getContainer(name).exec([
         'bash',
         '-c',
-        command
+        `${command}${command.match(/[\n\r]/) ? '' : ' 2>&1'}`
       ]);
 
       return { exitCode, output };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@centreon/js-config",
     "description": "Centreon Frontend shared build configuration",
-    "version": "24.4.31",
+    "version": "24.5.0",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/centreon/centreon-frontend.git"

package/webpack/base/index.js

@@ -63,7 +63,7 @@ const getBaseConfiguration = ({
           },
           {
             'react-i18next': {
-              requiredVersion: '11.x',
+              requiredVersion: '14.x',
               singleton: true
             }
           },

package/webpack/patch/module.js

@@ -1,46 +1,20 @@
-const fs = require('fs');
 const { CleanWebpackPlugin } = require('clean-webpack-plugin');
 
-class CentreonModulePlugin {
-  constructor(federatedComponentConfiguration) {
-    this.federatedComponentConfiguration = federatedComponentConfiguration;
-  }
+const WriteRemoteEntryNameToModuleFederation = require('../plugins/WriteRemoteEntryNameToModuleFederation');
+const TransformPreloadScript = require('../plugins/TransformPreloadScript');
 
-  apply(compiler) {
-    compiler.hooks.done.tap('CentreonModulePlugin', (stats) => {
-      const newFederatedComponentConfiguration = {
-        ...this.federatedComponentConfiguration,
-        remoteEntry: Object.keys(stats.compilation.assets).find((assetName) =>
-          assetName.match(/(^remoteEntry)\S+.js$/),
-        ),
-      };
-
-      if (!fs.existsSync(compiler.options.output.path)) {
-        fs.mkdirSync(compiler.options.output.path, { recursive: true });
-      }
-
-      fs.writeFileSync(
-        `${compiler.options.output.path}/moduleFederation.json`,
-        JSON.stringify(newFederatedComponentConfiguration, null, 2),
-      );
-    });
-  }
-}
-
-module.exports = ({
-  outputPath,
-  federatedComponentConfiguration,
-}) => ({
+module.exports = ({ outputPath, federatedComponentConfiguration }) => ({
   output: {
     library: '[chunkhash:8]',
-    path: outputPath,
+    path: outputPath
   },
   plugins: [
     new CleanWebpackPlugin({
       cleanOnceBeforeBuildPatterns: [`${outputPath}/**/*.js`],
       dangerouslyAllowCleanPatternsOutsideProject: true,
-      dry: false,
+      dry: false
     }),
-    new CentreonModulePlugin(federatedComponentConfiguration),
-  ],
+    new WriteRemoteEntryNameToModuleFederation(federatedComponentConfiguration),
+    new TransformPreloadScript(federatedComponentConfiguration)
+  ]
 });

package/webpack/plugins/TransformPreloadScript.js

@@ -0,0 +1,37 @@
+const fs = require('fs');
+
+const swc = require('@swc/core');
+
+module.exports = class TransformPreloadScript {
+  constructor(federatedComponentConfiguration) {
+    this.federatedComponentConfiguration = federatedComponentConfiguration;
+  }
+
+  apply(compiler) {
+    compiler.hooks.done.tap('CentreonModulePlugin', () => {
+      if (!fs.existsSync(compiler.options.output.path)) {
+        fs.mkdirSync(compiler.options.output.path, { recursive: true });
+      }
+
+      if (this.federatedComponentConfiguration.preloadScript) {
+        const { code } = swc.transformFileSync(
+          `./${this.federatedComponentConfiguration.preloadScript}.ts`,
+          {
+            filename: `${this.federatedComponentConfiguration.preloadScript}.ts`,
+            jsc: {
+              parser: {
+                syntax: 'typescript'
+              }
+            },
+            minify: true
+          }
+        );
+
+        fs.writeFileSync(
+          `${compiler.options.output.path}/${this.federatedComponentConfiguration.preloadScript}.js`,
+          code
+        );
+      }
+    });
+  }
+};

package/webpack/plugins/WriteRemoteEntryNameToModuleFederation.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+
+module.exports = class WriteRemoteEntryNameToModuleFederation {
+  constructor(federatedComponentConfiguration) {
+    this.federatedComponentConfiguration = federatedComponentConfiguration;
+  }
+
+  apply(compiler) {
+    compiler.hooks.done.tap(
+      'WriteRemoteEntryNameToModuleFederation',
+      (stats) => {
+        const newFederatedComponentConfiguration = {
+          ...this.federatedComponentConfiguration,
+          remoteEntry: Object.keys(stats.compilation.assets).find((assetName) =>
+            assetName.match(/(^remoteEntry)\S+.js$/)
+          )
+        };
+
+        if (!fs.existsSync(compiler.options.output.path)) {
+          fs.mkdirSync(compiler.options.output.path, { recursive: true });
+        }
+
+        fs.writeFileSync(
+          `${compiler.options.output.path}/moduleFederation.json`,
+          JSON.stringify(newFederatedComponentConfiguration, null, 2)
+        );
+      }
+    );
+  }
+};