README.md

# 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`

### 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 install <path to the JalHyd folder>/jalhyd-<version>.tar.gz`

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`


# Procédure d'ajout d'une calculette #

##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(ComputeNodeType.LechaptCalmon, 'L', ParamDomainValue.POS, rL);
					this._W = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'W', ParamDomainValue.POS, rW);
					this._A = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'A', 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è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);
				}
			}


* Créer les tests unitaires correspondants


* Ajouter une valeur à l'enum _ComputeNodeType_ pour identifier le type de noeud de calcul (par ex _MaCalculette_).


* Compléter la méthode _ComputeNodeParameters.getComputeNodeParameters()_.

	Si plusieurs valeurs de _ComputeNodeType_ font référence à la même calculette, n'ajouter les _case_ que pour les valeurs "concrètes". Par exemple, pour les sections paramétrées, il n'y a pas de _case_ pour la valeur _SectionParametree_ qui est générique.


##ngHyd


* Créer les fichier de configuration de la calculette
	- 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_ (2ème paramètre du constructeur)

		Ne pas oublier de spécifier :
			- le type de noeud de la calculette (dans l'objet comportant _"id":"options"_) avec le champ _"nodeType": "MaCalculette"_
			- éventuellement le type de noeud de fieldset particuliers (objets comportant _"id":"fs_XXX"_) avec le champ _"nodeType": "MaCalculetteBleue"_

	- dans _src/app/calculators/ma-calculette_ :
	
		Créer les fichiers d'internationalisation (_ma-calculette.&lt;langue&gt;.json_). Il doivent reprendre tous les ids utilisés dans le fichier de configuration et fournir leur traduction.

* Ajouter une valeur à l'enum _CalculatorType_ pour identifier la calculette.

	On ne reprend pas directement l'enum _ComputeNodeType_ car celui ci sert à distinguer les variantes au sein d'une même calculette (par exemple les différentes sections paramétrées).

* Composant CalculatorListComponent : ajouter une ligne au constructeur pour créer une nouvelle entrée dans la liste des calculettes disponibles.

* Classe _FormulaireService_, méthode _getConfigPathPrefix()_ : compléter le _switch_ pour fournir le préfixe des fichiers de configuration/internationalisation.

* Classe ParamService : compléter le constructeur.

* S'il existe plusieurs valeurs de _ComputeNodeType_ pour la même calculette, compléter les méthodes
	- _FormulaireDefinition.getComputeNodeTypeFromSection()_.
	- _ParamService.hasParameter()_

* _src/locale/error_messages.&lt;langue&gt;.json_ :
	Ajouter un champ pour le titre de la calculette. Par exemple :
		 _"INFO_MACALC_TITRE": "Ma calculette"_
	Compléter la méthode _GenericCalculatorComponent .uitextTitre()_ avec cette valeur et la valeur de l'enum _CalculatorType_ correspondante.

* Classe FormulaireDefinition : compléter la méthode _doCompute()_.
	En particulier, adapter les méthodes _getNubAndParameters()_ ou _getSectionNubAndParameters()_ (récupération des valeurs saisies dans l'interface).