Typo

rxjava/README.md

@@ -18,7 +18,7 @@ Ci-dessous la liste des Frameworks utilisés :
 
 ## Enoncé
 
-### B. Level 1
+### A. Level 1
 
 Anatomie d'un flux de données (**stream**)
 
@@ -36,7 +36,7 @@ RxJava met à disposition 3 méthodes à la disposition lors de la souscription.
  - notifie une erreur : `stream.subscribe(item -> {}, error -> {});`
  - notifie la fin du flux : `stream.subscribe(item -> {}, error -> {}, () -> {});`
 
-### A. Level 2
+### B. Level 2
 
 Création de flux de données
 
@@ -76,29 +76,29 @@ RX Java possède plusieurs types Java afin de spécialiser certains flux :
 | Flowable      | Un flux émettant une séquence de données potentiellement illimitée   | Oui            |
 
  - **Single** est une version limitée de **Observable**. Nous verrons plus tard que certains opérateurs ne sont pas disponibles avec un **Single**. Les méthodes **doOnNext** et **doOnComplete** sont remplacées par **doOnSuccess**. Dans une application web, **Single** est utilisé lorsqu'un service REST retourne une unique ressource.
- 
+
  - **Single** n'accepte pas la valeur `null`. **Maybe** accepte un flux vide et peut donc avoir une valeur ou aucune.
- 
+
  - **Completable** n'émet aucune valeur, il exécute une action sans retourner de valeur. En conséquence, il ne fournit pas de méthode **doOnNext**. Dans une application web, **Completable** est utilisé lorsqu'un service REST exécute un traitement sans retourner de résultat.
- 
+
  - **Flowable** est une version améliorée de **Observable** supportant la back pressure.
- 
+
 ### E. Level 5
- 
+
 Operators
- 
+
 RX Java est riche en opérateurs. Un opérateur permet d'altérer un flux d'événements ainsi obtenir un nouveau flux. Dans cette section, nous allons introduire certains des opérateurs les plus utilisés.
- 
+
 Il existe différents types d'opérateurs classés par catégorie.
- 
+
  - **Création** : `create`, `just`, `range`, `interval`
  - **Filtrage** : `filter`, `first`, `last`, `distinct`, `skip`, `take`
  - **Transformation** : `map`, `flatMap`, `scan`, `buffer`
  - **Combinaison** : `combineLatest`, `merge`, `concat`, `zip`
  - **Agregation** : `count`, `max`, `min`, `sum`, `reduce`
- 
+
 ### F. Level 6
- 
+
 Schedulers
 
 Par défault, les flux fonctionne sur le `thread` courant, c'est-à-dire le `thread` qui a souscrit le flux. Il s'agit du `thread` appelé `main` dans les exercices précédents. La majorité de nos exemples était des traitements synchrones, excepté certains exercices. Lorsqu'une opération a de la latence, l'émission synchrone impose cette latence au `thread` qui a souscrit.

spring-reactor/src/main/java/fr/ippon/codingdojo/service/impl/AccountServiceImpl.java

@@ -33,12 +33,11 @@ public class AccountServiceImpl implements AccountService {
     @Override
     @PreAuthorize("hasRole('EMPLOYEE')")
     public Mono<Void> closeAccount(String accountNumber) {
-        return accountRepository.findById(accountNumber)
-                .flatMap(accountRepository::delete);
+        return accountRepository.deleteById(accountNumber);
     }
 
     @Override
-    @PreAuthorize("hasAnyRole('EMPLOYEE')")
+    @PreAuthorize("hasRole('EMPLOYEE')")
     public Flux<Account> getAccounts() {
         return accountRepository.findAll();
     }
@@ -80,7 +79,7 @@ public class AccountServiceImpl implements AccountService {
     }
 
     @Override
-    @PreAuthorize("hasAnyRole('CUSTOMER')")
+    @PreAuthorize("hasRole('CUSTOMER')")
     public Flux<Transaction> getTransactions(String customerId, String accountNumber) {
         return accountRepository.findByCustomerIdAndNumber(customerId, accountNumber)
                 .flatMapMany(account -> Flux.fromIterable(account.getTransactions()));