Callbacks vs Promises vs Observables vs async/ await

JavaScript s'exécute d'une manière non bloquante, il exécute ligne par ligne, ce qui veut dire qu'il n'attends pas le résultat d'un code qui est asynchrone.

Nous pouvons travailler avec des opérations asynchrones, avec l'une des solutions suivantes :

• Callback : 
• Pros : qui est une fonction anonyme que nous passons en argument à notre méthode, et qui peut a son tour prendre des arguments (données), et permet de faire une exécution d'une manière asynchrone.
• Cons : "callback Hell", lorsqu'on plusieurs dépendances asynchrones, cela devient difficile à débugger et a gérer les erreurs.
• Promises :  Introduit depuis ES6 nativement sans besoin d'une librairie tier.
• Pros :  à l'intérieur de la méthode on crée une Promise avec le constructeur qui peut prendre des fonction en arguments : resolve , reject.  Puis, on appel resolve(data),  après l'appel de then() pour le retour des données.
• utile lorsque nous avons plusieurs dépendances asynchrones.
• Gestion des erreurs avec le bloc catch().
• Promise.all(iterable) 
• Promise.race(iterable)
• 
  
• Cons : Une seul opération asynchrone par promise.
• Ne permet pas de gérer plusieurs événements.
• Exemple : chargement des données avec une promesse
• const loadData = () => {
• return new Promise((resolves, rejects) => {
• const api  = 'xxx';
• const request = new XMLHttpRequest();
• request.open('GET', api);
• request.onload = ()  => {
• if (request.status === 200 ){ resolves(JSON.parse (reuqest.reponse));
• }else { rejects (Error(request.statusText));
• }
• };
• request.onerror = err => rejects (err);
• request.send();
• });
• }; 
•  Appel avec then()
• fetch()  est une bonne alternative pour faire des appels d'API. C'est une fonction native dans le navigateur et dans Nodejs aussi.
• RxJS Observables : utile lorsqu'on a un flux de données au lieu d'une seul valeur.
• 
• Async et await:  ne remplacent pas les promesses, ils les complètent.

Le mot-clé await permet d’attendre la résolution d’une opération asynchrone et d’en récupérer le résultat. Dès que le mot-clé await est utilisé au sein d’une fonction, celle-ci doit avoir le mot-clé async présent dans sa signature. Ce mot-clé définit que la fonction contient une opération asynchrone et que le moteur JavaScript doit attendre sa résolution pour poursuivre l’exécution du code de la fonction.

le mot-clé async a également un autre impact : une fonction déclarée async retourne toujours une promesse.

https://academind.com/learn/javascript/callbacks-vs-promises-vs-rxjs-vs-async-awaits/
https://stackoverflow.com/questions/37364973/what-is-the-difference-between-promises-and-observables

file downloading in restful web services

Exemple d'utilisation de ResponseBuilder

Git: erreur rejected non-fast-forward

Lorsque vous rencontrez cette erreur :

le problème est que la branche à partir de laquelle vous avez pull, le code a changé depuis sur le remote server.

Du coup, vous pouvez suivre les étapes suivantes pour résoudre se problème :

1. faire un Pull
2. faire un Push avec vos modifications

Liens utile :

https://git-scm.com/book/en/v2/Git-Basics-Working-with-Remotes

Java parcourir les fichiers dans un répertoire.

Java 8 : Files.list(repertoire) ou Files.walk(repertoire)  retourne la liste des fichiers dans un répertoire.
Java 7 : Files.walkFileTree() : prend un path
Java 6 : File.listFiles()

Java : La lecture d'un fichier CSV

1. La lecture d'un fichier CSV en Java :

try(BufferedReader br = new BufferedReader(new FileReader("somefile.txt")) ) {
 String columnNames = br.readline(); // ONLY do this if it exists
String line; while ((line = br.readLine()) != null) {
/* parse each line */ // TODO }
} catch (Exception e) {
 System.err.println(e.getMessage()); // or log error
}
/!\  Si fichier distant : URL url = new URL("http://url/textfile.txt");
Puis, (url.openStream()

Pistes :

•  Apache Commons CSV parser library

/* parse each line */ 

CSVParser parser = CSVParser.parse(line, CSVFormat.RFC4180); 

for(CSVRecord cr : parser) { 

int id = cr.get(1); // columns start at 1 not 0 !!! 

int year = cr.get(2); 

String city = cr.get(3); 

}

Java : Solution pour éviter que votre méthode retourner null

Collections.emptyList() : retourne une liste immuable prédéfinie, ou bien, List.of() introduit dans la JDK9.

https://blog.octo.com/comment-ne-plus-avoir-de-nullpointerexception-en-java/

Java : Un guide pour choisir la structure de données approprié à votre cas.

L'interface Set modélise un ensemble d'objets dans lequel on ne peut pas trouver de doublons.

Un Set ne peut pas contenir plus d'un objet null.

Implémentations HashSet et LinkedHashSet

  

TreeSet implémente NavigableSet

log(n) time cost for the basic operations (add, remove and contains).

https://dzone.com/articles/the-hidden-contract-between-equals-and-comparable

TreeSet implémente SortedSet, alors que HashSet n'implémente "que" Set.

  

Dit autrement, TreeSet implémente un ensemble ordonné : si tu itères sur les éléments du TreeSet, tu les obtiendras en ordre croissant (selon la méthode compareTo() de Comparable).

Par ailleurs, TreeSet repose sur la méthode compareTo() pour fonctionner. HashSet repose sur la méthode hashCode().

Si tu as besoin d'avoir un ensemble trié -> TreeSet

Sinon -> HashSet (car plus rapide)

List est la solution si on veut garder l'ordre par defaut, mais si on doit réordonner les données il faut utiliser une autre structure comme TreeSet .

Source : http://www.sergiy.ca/guide-to-selecting-appropriate-map-collection-in-java

Sorted vs Ordred : https://stackoverflow.com/questions/1084146/what-is-the-difference-between-an-ordered-and-a-sorted-collection

Angular 8: le timing des décorateurs @ViewChild @ViewChildren

 Angular 8, il est obligatoire de renseigner une propriété static sur le ViewChild et ContentChlid

https://stackoverflow.com/questions/56359504/how-should-i-use-the-new-static-option-for-viewchild-in-angular-8

Queries timing

Source : https://blog.ninja-squad.com/2019/05/29/what-is-new-angular-8.0/

The ViewChild and ContentChild decorators now must have a new option called static. Let me explain why with a very simple example using a ViewChild:

 *ngIf="true">
  


 #dynamicDiv>dynamic

Let’s get that element in our component and log it in the lifecycle hooks ngOnInit and ngAfterViewInit:

@ViewChild('dynamicDiv') dynamicDiv: ElementRef<HTMLDivElement>;

ngOnInit() {
  console.log('init dynamic', this.dynamicDiv); // undefined
}

ngAfterViewInit() {
  console.log('after view init dynamic', this.dynamicDiv); // div
}

Makes sense as AfterViewInit is called when the template initialization is done.

But in fact, if the queried element is static (not wrapped in an ngIf or an ngFor), then it is available in ngOnInit also:

 #staticDiv>static

gives:

@ViewChild('staticDiv') staticDiv: ElementRef<HTMLDivElement>;

ngOnInit() {
  console.log('init static', this.staticDiv); // div
}

ngAfterViewInit() {
  console.log('after view init static', this.staticDiv); // div
}

This was not documented, or recommended, but that’s how it currently works.

With Ivy though, the behavior changes to be more consistent:

ngOnInit() {
  console.log('init static', this.staticDiv); // undefined (changed)
}

ngAfterViewInit() {
  console.log('after view init static', this.staticDiv); // div
}

A new static flag has been introduced to not break existing applications, so if you want to keep the old behavior even when you’ll switch to Ivy, you can write:

@ViewChild('static', { static: true }) static: ElementRef<HTMLDivElement>;

and the behavior will be the same as the current one (the element is also accessible in ngOnInit).

Note that if you add static: true on a dynamic element (wrapped in a condition or a loop), then it will not be accessible in ngOnInit nor in ngAfterViewInit!

static: false will be how Ivy behaves by default.

To not break existing applications and to ease the migration, the Angular team wrote a schematic that automatically analyzes your application, and adds the static flag. It even offers two strategies:

• one based on your templates, which will make sure that your application works (so it tends to mark queries as static even when they aren’t). You are sure it works, but it exposes you to problems if you wrap your static element in a condition or a loop later.
• one based on your usage of the query, which is more error-prone (as it is harder for the schematic to figure it out), but will not mark the queries as static if they don’t need to be. So most queries will have static: false, which will be the default in Ivy.

The first strategy is used by default when you run ng update because it is the safest, but you can try the usage strategy by using NG_STATIC_QUERY_USAGE_STRATEGY=true ng update.

You can check out the official guide for more information.

This is what the migration looks like (with a failure in one component):

------ Static Query Migration ------
With Angular version 8, developers need to
explicitly specify the timing of ViewChild and
ContentChild queries. Read more about this here:
https://v8.angular.io/guide/static-query-migration

Some queries could not be migrated automatically. Please go
those manually and apply the appropriate timing.
For more info on how to choose a flag, please see:
https://v8.angular.io/guide/static-query-migration
⮑   home/home.component.ts@43:3: undefined

Note that this only concerns ViewChild and ContentChild, not ViewChildren and ContentChildren (which will work the same way in Ivy and View Engine).

Spring Data

Implémentant les opérations de base et le design pattern Repository du DDD (Domain Driven Design),
Spring Data s'interface avec plusieurs sources de données parmi lesquelles JPA, Neo4j, MongoDB, GemFire, Hadoop, ElasticSearch, REST, Redis, Couchbase et quelques autres, via Spring Data Commons
il contient trois interfaces qui prennent deux types de paramètres :

•  le type de l'entité que l'on manipule et
•  le type de l'identifiant de l'entité  
• Repository, 
• CrudRepository :  méthodes CRUD pour la source de données sous-jacente (save, findOne, findAll, etc.).
• PagingAndSortingRepository:un ensemble de méthodes permettant de faire de la pagination et du tri

https://stackoverflow.com/questions/41930627/spring-jpa-data-pageable-pagerequest

http://blog.soat.fr/2014/02/spring-data-une-autre-facon-dacceder-aux-donnees/

3 different XML design styles: Russian Dolls,Salami Slice,and Venetian Blind

http://timzhao.blogspot.com/2010/09/3-different-xml-design-styles-russian.html
https://mostlybuggy.wordpress.com/2012/06/06/note-to-self-xml-schema-design-patterns-in-a-nutshell/

Le modèle le plus utilisé est : Russian Doll (ou poupée Russe). Ce design pattern propose d’utiliser un seul élément racine global (la grande poupée) pour tous les éléments qu’il contient (les autres poupées s’imbriquent dans la principale). Ainsi, toutes les balises et éléments à l’intérieur de cette racine sont des éléments locaux. Le modèle de conception Russian Doll utilise les caractéristiques suivantes :

• Le document est composé d’une seule racine globale.
• Tous les types sont locaux.
• Le Schema XML associé doit être présent dans un seul fichier.
• Le Schema est complet car il encapsule les types.
• C’est le modèle le plus simple à lire et à écrire.

Le design pattern DTO : containers de données

Le design pattern Data Transfer Object (DTO) de préference immuable est un conteneur métier respectant les spécifications fonctionnelles au niveau des constructeurs et des attributs, mais n’implémentant aucune logique métier au niveau de ses méthodes. Une classe DTO est, en effet, uniquement un conteneur permettant de transporter des informations métier.

Chaque classe DTO respecte le standard POJO et offre ainsi la sérialisation permettant la communication avec n’importe quels plate-forme et langage. DTO est un nom générique utilisé pour le transfert des données. Ce type d’objet préserve la simplicité de la sémantique et de la manipulation des classes tout en proposant une communication distante dans une architecture distribuée.

Cette technique consiste à créer une instance DTO contenant toutes les données nécessaires, puis à modifier la signature de la méthode distante pour qu’elle accepte le DTO en tant que paramètre unique. Une fois que l’application appelante a reçu et stocké le DTO en local, celle-ci peut utiliser le DTO comme objet local. Le but étant de créer des objets de transfert afin de récupérer un maximum d’informations ou des informations selon une structure particulière en une seule étape.
La structure de ces objets est composée de l’union des attributs issus des objets métiers dont les informations doivent être manipulées par notre application et accessibles par l’intermédiaire des getters et setters correspondants.

Vulgarisation de OAuth 2.0

OAuth est un framework  ou protcole qui fourni un accès au serivce HTTP pour implémenter l’autorisation avec plusieurs extensions qui varie d'un "vendor" à l'autre, comme Google, Facebook, LinkedIn.

Un exemple d'extension est OpenID Connect OIDC qui permet de créer un profil pour l’authentification and SSO.

Third Party access.

Vocabulaire :

• scopes, flow ou grant type : définie comment le client va obtenir une autorisation (permission) à partir d'un Ressource Owner 
• Scope : permission, definie les actions que  l'application client peut faire sur une ressource donnée.
• token est lié à un Scope .
• Oauth 2.0 Actors :
• Ressource Owner : Celui qui possède la ressources (la données à protéger). Par exemple mon "profil LinkedIn" ou "Mur Facebook" est la données à protéger et je suis le propriétaire de cette ressources.
• Client est l’application (Mobile / Cloud ) qui veut accéder à la ressource que j'utilise et qui a besoin d’accéder à mon profil 
• Resource Server - Provider: L'endroit qui héberge les ressources protégé. C'est LinkedIn qui contient les données de mon compte.
• Authorization Server - OAuth Provider : c'est l’entité STS Security Token  service qui va donner le Jeton OAuth 2.0 d’accès  "Token" au Resource Server. Dans l'exemple suivant c'est Facebook ou Linkedin. Il est composé de 3 composnats :
• Authentification : une page de login qui s'affiche sur le Browser Identity provider  l'infrastructure IAM 
• Composant (consent server )qui demande le consentement de l'utilisateur authentifier pour la délegation de  droits d'accès au client (Application)
•  

Les Types de tokens :

• Access token : permet d'identifier le user, 2 types Sharing by Reference (sort de sessionid) coté serveur ou By value self-contained token (JWT) coté client. 
• Refresh token (stocker par le client ): permet de renouveler l'access tocken lorsqu'il expire, puet être utiliser pour demander un nouveau Access Token AT.
• Scopes se sont les permissions.
• Authorization Code (code):  Authorization Server  crée ce code et l'envoie au client (expire dans quelque minute).

 Credentilas (identifiants):

• Resource Owner Credentials 
• Client Credentials: ClinetId & ClientSecret
• Access token
• Refresh token
• Authorization Code

Client registration :

• Avec OAuth Provider 
• Le client fourni à OAuth Provider 
• Redirect URI
• Le Scope requis 
• En retour OAuth Provider  fourni au client 
• ClientId
• ClientSecret

OAuth 2.0 Grant types :
il y a différentes types de grants qui impact le flow :

• Client Credential grant : communication entre deux services. 
• Implicit grant type
• Resource owner password credentials grant type
• Authorization code grant type : est le plus utilisé . vous donnez votre accord d'accès à quelqu'un d'autre en votre nom.

https://docs.oracle.com/cd/E39820_01/doc.11121/gateway_docs/content/oauth_flows.html
Challenges :
Exemple de flux de délégation  d'accès avec OAuth 2.0:

1. Un utilisateur visite une application web tier et veut permettre  à cette application de publier les messages sur son mur Facebook. L'application Web à besoin de récupérer des tokens de Facebook, donc pour avoir ces token l'utilisateur va être rediriger vers Facebook.
2. Facebook affiche une pop up d'authentification(s'il n'est pas déjà authentifié), et demande le consentement de l'utilisateur pour donner les permissions à l'application web tier pour publier des messages dans son mur Facebook.
3. L'utilisateur s'authentifie et fournie son consentement à Facebook, et Facebook partage le token avec l'application Web tier pour une période limité et uniquement avec les autorisations accordées. L'application web tier, ne peut pas par exemple envoyé une demande pour ajouter des nouveaux amis, ou supprimer le message du status, télécharger une photos, etc ... avec ce token.
4. L'application web tier récupère le token de Facebook. Pour comprendre ce qui se passe dans cette étape nous devons comprendre comment les types de Grants fonctionne??? 
5. L'application web tier accède à l'API Facebook avec le token qui a été fourni par Facebook dans la étape précédente. L'API Facebook s'assure  que uniquement les requêtes qui ont un token valid peuvent avoir accès.  

JSON Schema : How to specify that a string property contains base64-encoded PNG images

By adding : The contentMediaType and contentEncoding



Example

Here is an example schema, illustrating the use of "contentEncoding" and "contentMediaType":

{
    "type": "string",
    "contentEncoding": "base64",
    "contentMediaType": "image/png"
}

                    

Instances described by this schema should be strings, and their values should be interpretable as base64-encoded PNG images.

Another example:

{
    "type": "string",
    "contentMediaType": "text/html"
}

                    

Instances described by this schema should be strings containing HTML, using whatever character set the JSON string was decoded into (default is Unicode)

 contentEncoding

If the instance value is a string, this property defines that the string SHOULD be interpreted as binary data and decoded using the encoding named by this property. RFC 2045, Sec 6.1 [RFC2045]lists the possible values for this property.

The value of this property MUST be a string.

contentMediaType

The value of this property must be a media type, as defined by RFC 2046 [RFC2046]. This property defines the media type of instances which this schema defines.

The value of this property MUST be a string.

The value of this property SHOULD be ignored if the instance described is not a string.

If the "contentEncoding" property is not present, but the instance value is a string, then the value of this property SHOULD specify a text document type, and the character set SHOULD be the character set into which the JSON string value was decoded (for which the default is Unicode).

More informations : https://stackoverflow.com/questions/51675207/json-schema-is-it-possible-to-validate-a-string-is-a-json-array-or-object/51699771#51699771

Git : How test pushing the feature/feature1 branch to a remote origin?

Il faut utiliser l'option --dry-run de push, pour voir si vous avez les droits!

git push --dry-run origin feature/feature1

Git : When to Use Git Reset, Git Revert & Git Checkout

https://dev.to/neshaz/when-to-use-git-reset-git-revert--git-checkout-18je

Mockito : « Stubbing » pré-programmés l'objet avec les attentes du système à tester.

Le stubbing permet de définir le comportement des objets mockés face aux appels de méthodes sur ces objets.

Plusieurs méthodes de stubbing sont possibles :

1. Retour d’une valeur unique

Mockito.when(user.getLogin()).thenReturn(‘user1’); //la chaine de caractères user1 sera renvoyée quand la méthode getLogin() sera appelée.

2. Faire appel à la méthode d’origine

Mockito.when(user.getLogin()).thenCallRealMethod();

3. Levée d’exceptions

Mockito.when(user.getLogin()).thenThrow(new RuntimeException());

Il faut noter que la méthode retournera toujours la valeur stubbée, peu importe combien de fois elle est appelée . Si on stubb la même méthode ayant la même signature plusieurs fois, le dernier stubbing sera pris en compte.

Mockito.when(user.getLogin()).ThenThrow(new RuntimeException()).ThenReturn(« foo »);

Ici le premier appel va lever une exception, tous les appels qui suivront retourneront « foo ».

4. Retours de valeurs consécutives

Mockito.when(user.getLogin()).thenReturn(‘user1’,’user2’,’user3’);

Le premier appel retourne user1, le deuxième retournera user2 le troisième user3. Tous les appels qui suivent retourneront la dernière valeur c’est à dire user3.

5. Ne rien retourner

 Mockito.doNothing().when(user.getLogin());

Writing Clean Tests – To Verify Or Not To Verify

https://manas.tech/blog/2009/04/30/state-vs-behaviour-verification.html
https://www.petrikainulainen.net/programming/testing/writing-clean-tests-to-verify-or-not-to-verify/

How A typical Jenkins build works? Comment fonctionne un build type avec Jenkins?

Le développeur modifie le code: le développeur commit le nouveau code dans le gestionnaire

de version (généralement Git ou Subversion) et le fait un push au répo central.

Le code est transmis au serveur de build: Jenkins surveille le répo en permanence.

Lorsqu'il voit un nouveau commit, il vérifie que la  version du code compile

Le build de l'application: à l'aide de scripts de build également commiter pour le répo,

Jenkins construit (build) le logiciel.

Exécutez les tests automatisés: des tests unitaires et / ou des tests d'intégration sont

également gérés par l'équipe de développement dans le cadre du projet.
Jenkins utilise un script de test pour exécuter ces tests.

Notifier les développeurs des problèmes: Jenkins maintient une liste de résultats des

builds que les développeurs peuvent facilement visualiser à l'aide de son interface Web.

Jenkins peut également être configuré pour envoyer des emails aux développeurs en cas d'échec du build.

Java :Strings Cookbooks and Examples

https://github.com/eugenp/tutorials/tree/master/java-strings

https://dzone.com/articles/java-12-string-api-updates

Git : Delete HTTPS remote and add Git remote

git remote -v

git remote remove origin

git remote add origin git@git.ra1

ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/t//.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /t//.ssh/id_rsa.
Your public key has been saved in /t//.ssh/id_rsa.pub.
The key fingerprint is:

Git : You which to remove untracked Files (not in the repository ou the working tree)

Caustion :
Use git clean -n : For Dry-run to see the final result, then
use git clean -f 

Git : add tracked files only

git add -u stages modifications and deletions, without new files
looks at all the already tracked files and stages the changes to those files if they are different or if they have been removed. It does not add any new files, it only stages changes to already tracked files.

git add -i You can select specific files and easily update, patch, or revert them.

Java : Converting a Collection to an Array

Use liste.toArray()

Java : Supprimer un element de la liste à l'interieur d'une boucle for (Remove an Element from a List Inside a Loop)

Iterator iter = list.iterator(); while (iter.hasNext()) {
// next() Doit être appelé avant la méthode remove(), sinon la taille (size) de Arraylist va changer.
String s = iter.next();
if (s.equals("a")) {
iter.remove();
}
}

Java : Check If an Array Contains a Value

Arrays.asList(arr).contains(targetValue);

Java : Convert Array to ArrayList

Before Java 8 :

List targetList = new ArrayList(Arrays.asList(sourceArray));

Apache Commons Collections : 

Personne[] sourceArray = { P0, P1, P2, P3, P4, P5 };
List targetList = new ArrayList<>(6);
CollectionUtils.addAll(targetList, sourceArray);

After Java 8 : 

List<Personne> targetList = Arrays.stream(sourceArray).boxed().collect(Collectors.toList());