Skip to content
Snippets Groups Projects

ngHyd : Angular Component Library For Hydraulics using JaLHyd library

All the things to know for developping the library

The library needs nodeJS installed and the following node packages installed globally: typescript, karma, tslint.

This can be done from the command line:

npm install -g typescript karma tslint

The documentation of Cassiopee needs to install MkDocs and some extensions:

sudo apt install python3-pip
python3 -m pip install mkdocs
python3 -m pip install python-markdown-math
python3 -m pip install mkdocs-material

Install the necessary packages of the library:

Clone or update the JalHyd project and in the JalHyd folder, run :

npm package

Then, back to the ngHyd project folder, run :

npm run jalhyd

and then :

npm install

To compile the typescript code

npm run build

To run compilation in watch mode as well as application execution in a navigator window

npm start

To flag suspicious language usage

npm run lint

Caveats

Deployment

Custom Material SVG Icons will only show up when the application is deployed on the domain root (no subfolders), see this feature request

Procédure d'ajout d'un module de calcul

JaLHyd

  • Créer la classe de paramétrage

    • exemple :

        export class TotoParams extends ParamsEquation {
        	[key: string]: any; // pour pouvoir faire this['methode]();
      
        	/** Longueur L */
        	private _L: ParamDefinition;
      
        	/** Largeur W */
        	private _W: ParamDefinition;
      
        	/** Tugudu A */
        	private _A: ParamDefinition;
      
        	constructor(rL: number, rW: number, rA:number=undefined) {
        		super();
        		this._L = new ParamDefinition(this, ComputeNodeType.LechaptCalmon, 'L', "m", ParamDomainValue.POS, rL);
        		this._W = new ParamDefinition(this, ComputeNodeType.LechaptCalmon, 'W', "m", ParamDomainValue.POS, rW);
        		this._A = new ParamDefinition(this, ComputeNodeType.LechaptCalmon, 'A', undefined, ParamDomainValue.POS, rA);
      
        		this.addParamDefinition(this._L);
        		this.addParamDefinition(this._W);
        		this.addParamDefinition(this._A);
        	}
      
        	get L() {
        		return this._L;
        	}
      
        	get W() {
        		return this._W;
        	}
      
        	get A() {
        		return this._A;
        	}
        }
  • Créer la classe de calcul

    • exemple :

        export class Toto extends Nub {
        	constructor(prms: TotoParams, dbg: boolean = false) {
        		super(prms, dbg);
        		// paramètre à calculer par défaut
        		this._defaultCalculatedParam = prms.A;
        		this.resetDefaultCalculatedParam();
        	}
      
        	/**
        	* paramètres castés au bon type
        	*/
        	get prms(): TotoParams {
        		return <TotoParams>this._prms;
        	}
      
        	/**
        	* paramétrage de la calculabilité des paramètres
        	*/
        	protected setParametersCalculability() {
        		this.prms.L.calculability = ParamCalculability.DICHO;
        		this.prms.W.calculability = ParamCalculability.DICHO;
        		this.prms.A.calculability = ParamCalculability.EQUATION;
        	}
      
        	Equation(sVarCalc: string): Result {
        		let v: number;
      
        		switch (sVarCalc) {
        			case "A":
        				v = this.prms.L.v / this.prms.W.v;
        				break;
      
        			default:
        				throw "Toto.Equation() : invalid variable name " + sVarCalc;
        		}
      
        		return new Result(v, this);
        	}
        }
  • Créer les tests unitaires correspondants

  • Ajouter une valeur à l'enum CalculatorType pour identifier le type de module de calcul (par ex MaCalculette).

  • Compléter la méthode Session.createNub().

ngHyd

  1. Créer les fichiers de configuration du module de calcul

    • dans src/app/calculators : créer un répertoire (par ex ma-calculette)

    • dans src/app/calculators/ma-calculette :

      Créer ma-calculette.config.json sur le modèle des autres. Les ids utilisés doivent correspondre au symbole fourni à classe ParamDefinition (1er paramètre du constructeur)

      Ne pas oublier de spécifier :

      • éventuellement le type de noeud par défaut du module de calcul dans les options avec le champ "defaultNodeType". Si ce champ est absent, sa valeur est "ComputeNodeType.None". Ce champ sert par ex pour les sections paramétrées à déterminer le type de section à afficher lors de la création du module de calcul.

      • éventuellement le type de noeud de paramètres particuliers (objets comportant "type":"input") avec le champ "nodeType": "MaCalculetteBleue" (par défaut, "ComputeNodeType.None")

    • dans src/app/calculators/ma-calculette :

      Créer les fichiers d'internationalisation (ma-calculette.<langue>.json). Il doivent reprendre tous les ids utilisés dans le fichier de configuration et fournir leur traduction.

  2. Si nécessaire créer la classe du formulaire dans src/app/formulaire/definition/concrete . Une classe de base gérant la majorité des cas est déjà disponible, en général cette étape n'est pas nécessaire

    • Par ex : FormulaireMaCalculette dans src/app/formulaire/definition/concrete/form-ma-calculette.ts

      Ces classes concrètes sont construites par composition des classes dans src/app/formulaire/definition :

      • form-def-* : définition/description du formulaire.
        • FormDefSection : avec paramètre à varier
        • FormDefParamToCalculate : avec paramètre à calculer
        • etc...
      • form-compute-* : aspects calculatoires
      • form-result-* : affichage des résultats

      On peut soit composer la classe concrète directement avec ces classes, soient dériver ces dernières et composer avec.

  3. src/locale/messages.<langue>.json : Ajouter un champ pour le titre du module de calcul. Par exemple : "INFO_MACALC_TITRE": "Ma calculette"

  4. Dans le constructeur de FormulaireService, ajouter une entrée dans this.calculatorPaths pour fournir le préfixe des fichiers de configuration/internationalisation.

  5. Si une nouvelle classe a été créée à l'étape 2, dans la méthode FormulaireService.newFormulaire(), compléter le switch pour fournir la classe à instancier.

Build under Windows

Several npm scripts of package.json won't work with windows (for ex. "preprocess"). Building is a little more complicated.

install dependencies

build jalhyd

Clone jalhyd repository.

Install packages with npm install.

As preprocess does not work, copy src/date_revision.ts file from a linux build, or create it with the following (example) content :

export const jalhydDateRev = "2019-05-24";
export const jalhydVersion = "stable-105-gdfc538b";

As mkdocs does not work, copy src/assets/docs-fr folder from a linux build.

Compile jalhyd with tsc --p "src/tsconfig.app.json"

build nghyd

Clone nghyd repository.

Install packages with npm install.

As preprocess does not work, copy src/date_revision.ts file from a linux build, or create it with the following (example) content :

export const nghydDateRev = "2019-05-28";
export const nghydVersion = "4.3.0-119-ga6ef812";

Compile nghyd with ng build --prod --build-optimizer=false

Build desktop packages with Electron

linux .deb package

Execute npm run release-linux. Find the .deb package in /release.

Running dpkg -i cassiopee_*.deb will install Cassiopée in /opt/Cassiopee

windows installer

Follow "Build under Windows" instructions first (see above). Then,

install dependencies

  • electron-builder (system wide) : npm install -g electron-builder

Build package with electron-builder. Find the generated installer in /release.

Running the generated installer will install Cassiopée in C:\Users\YourUser\AppData\local\Programs\cassiopee

Build mobile packages with Cordova

Cordova embeds the whole app in a Web view, allowing it to run on mobile devices

Android .apk

install dependencies

  • java (system wide) : for ex. apt install oracle-java8-jdk
  • cordova (system wide) : npm install -g cordova
  • gradle (system wide) : apt install gradle

install Android Studio and SDKs

Download Android Studio here and install it : https://developer.android.com/studio

Run Android Studio, click "configure > SDK manager". Install at least one SDK, for ex. 7.0 Nougat.

Build .apk package with npm run release-android. Find the generated package in /release.