Reactive Programming

1[
2    {
3        "customerDTO": {
4            "scanAvailable": true
5        },
6        "bankAccountDTOs": {
7            "scanAvailable": true,
8            "prefetch": -1
9        }
10    }
11]
12public class ResponseClientDTO {
13    private Mono<CustomerDTO> customerDTO;
14    private Flux<BankAccountDTO> bankAccountDTOs;
15}
16public Flux<ResponseClientDTO> getCustomerWithBankAccounts(String customerId){
17    Flux<BankAccountDTO> bankAccounts = webClient
18        .get()
19        .uri(uriBuilder -> 
20                uriBuilder.path("customers")
21                .queryParam("customerId", customerId).build())
22        .accept(MediaType.APPLICATION_JSON)
23        .retrieve()
24        .bodyToFlux(BankAccountDTO.class);
25        
26    
27    Mono<CustomerDTO> cMono = findOne(customerId);
28    
29    ResponseClientDTO responseClientDTO = new ResponseClientDTO();
30    responseClientDTO.setBankAccountDTOs(bankAccounts);
31    responseClientDTO.setCustomerDTO(cMono);
32    
33    return Flux.just(responseClientDTO);
34}
35public class ResponseClientDTO {
36    private CustomerDTO customerDTO;
37    private List<BankAccountDTO> bankAccountDTOs;
38}
39

1[
2    {
3        "customerDTO": {
4            "scanAvailable": true
5        },
6        "bankAccountDTOs": {
7            "scanAvailable": true,
8            "prefetch": -1
9        }
10    }
11]
12public class ResponseClientDTO {
13    private Mono<CustomerDTO> customerDTO;
14    private Flux<BankAccountDTO> bankAccountDTOs;
15}
16public Flux<ResponseClientDTO> getCustomerWithBankAccounts(String customerId){
17    Flux<BankAccountDTO> bankAccounts = webClient
18        .get()
19        .uri(uriBuilder -> 
20                uriBuilder.path("customers")
21                .queryParam("customerId", customerId).build())
22        .accept(MediaType.APPLICATION_JSON)
23        .retrieve()
24        .bodyToFlux(BankAccountDTO.class);
25        
26    
27    Mono<CustomerDTO> cMono = findOne(customerId);
28    
29    ResponseClientDTO responseClientDTO = new ResponseClientDTO();
30    responseClientDTO.setBankAccountDTOs(bankAccounts);
31    responseClientDTO.setCustomerDTO(cMono);
32    
33    return Flux.just(responseClientDTO);
34}
35public class ResponseClientDTO {
36    private CustomerDTO customerDTO;
37    private List<BankAccountDTO> bankAccountDTOs;
38}
39public Mono<ResponseClientDTO> getCustomerWithBankAccounts(String customerId){
40    Flux<BankAccountDTO> bankAccounts = webClient
41        .get()
42        .uri(uriBuilder -> 
43                uriBuilder.path("customers")
44                .queryParam("customerId", customerId).build())
45        .accept(MediaType.APPLICATION_JSON)
46        .retrieve()
47        .bodyToFlux(BankAccountDTO.class);
48        
49    Mono<CustomerDTO> cMono = findOne(customerId);
50    
51    return bankAccounts.collectList().zipWith(cMono).map(data -> {
52        ResponseClientDTO responseClientDTO = new ResponseClientDTO();
53        responseClientDTO.setBankAccountDTOs(data.getT1());
54        responseClientDTO.setCustomerDTO(data.getT2());
55    })
56}
57

1class MyController: NSObject, ObservableObject {
2
3    //...
4
5    @Published var myRapidlyChangingVar: MyEnum? = nil
6
7    //...
8
9    func calledAtHighFrequencyByExternalEvents(value: MyEnum) {
10        myRapidlyChangingVar = value
11    }
12}
13let cancellable = myRapidlyChangingVar
14    .compactMap { $0 }
15    .debounce(for: .seconds(1), scheduler: DispatchQueue.main)
16    .sink { [weak self] _ in self?.myRapidlyChangingVar = nil }
17}
18

1var isComplete: Bool {
2    Set([.givenName, .familyName]).isSubset(of: elements)
3}
4struct EditPersonView: View {
5    
6    let model: ViewModel
7            
8    private var captionView: some View {
9        HStack {
10        /*
11          stuff
12        */
13            if submitted && model.name.isComplete {
14                Spacer()
15                Text("select".localizedCapitalized) + Text(" ") + Text("save") + Text(" ") + Text("👆")
16            }
17        }
18    }
19
20    var body: some View {
21    /*
22    stuff - including captionView
23    */
24    }
25}
26
27extension EditPersonView {
28    
29    final class ViewModel {
30        
31        let name: PersonName
32        
33        init(person: Person) {
34            self.name = PersonName(for: person)
35        }
36    }
37}
38
39extension EditPersonView.ViewModel {
40    
41    final class PersonName {
42        
43        let person: Person
44        
45        private let formatter = PersonNameComponentsFormatter()
46        
47        init(for person: Person) {
48            self.person = person
49        }
50        
51        var text: String {
52            get { person.name ?? "" }
53            set { person.name = newValue }
54        }
55        
56        private var components: PersonNameComponents? {
57            formatter.personNameComponents(from: text)
58        }
59        
60        var givenName: String? {
61            components?.givenName
62        }
63        
64        var familyName: String? {
65            components?.familyName
66        }
67        
68        private func isValid(component: String?) -> Bool {
69            if let name = component, name.count > 1 {
70                return true
71            }
72            return false
73        }
74        
75        var elements: Set<Elements> {
76            var collection = Set<Elements>()
77            if isValid(component: givenName) { collection.insert(.givenName) }
78            if isValid(component: familyName) { collection.insert(.familyName) }
79            return collection
80        }
81        
82        var isComplete: Bool {
83            Set([.givenName, .familyName]).isSubset(of: elements)
84        }
85    }
86}
87
88extension EditPersonView.ViewModel.PersonName {
89    
90    enum Elements {
91        case givenName, familyName
92    }
93}
94final class PersonName {
95    var person: Person
96
97    private let formatter = PersonNameComponentsFormatter()
98
99    let textPublisher = PassthroughSubject<String, Never>()
100    var text: String {
101        get { person.name ?? "" }
102        set { textPublisher.send(newValue); person.name = newValue }
103    }
104
105    var isComplete : AnyPublisher<Bool, Never>!
106
107    init(for person: Person) {
108        self.person = person
109
110        isComplete = textPublisher
111            .map{ self.formatter.personNameComponents(from: $0) }
112            .map{ (components: PersonNameComponents?) -> Set<Elements> in
113                var collection = Set<Elements>()
114
115                if let components = components {
116                    if self.isValid(component: components.givenName) { collection.insert(.givenName) }
117                    if self.isValid(component: components.familyName) { collection.insert(.familyName) }
118                }
119
120                return collection
121            }
122            .map { Set([Elements.givenName, Elements.familyName]).isSubset(of: $0) }
123            .eraseToAnyPublisher()
124    }
125
126    private func isValid(component: String?) -> Bool {
127        if let name = component, name.count > 1 {
128            return true
129        }
130        return false
131    }
132}
133

1public Mono<List<Response>> getRecords(String input){
2
3List<Response> response = new ArrayList<>();
4
5Mono<FirstApiResponse> gResp = this.firstWebClient.get().uri(uriBuilder -> uriBuilder
6            .path("/")
7            .queryParam("q", input)
8            .build()).retrieve()
9            .bodyToMono(FirstApiResponse.class).log()
10            .timeout(Duration.ofSeconds(50L));
11
12Mono<SecondApiResponse> iResp = this.secondWebClient.get().uri(uriBuilder -> uriBuilder
13        .path("/search")
14        .queryParam("term", input)
15        .build()).retrieve()
16        .bodyToMono(SecondApiResponse.class).log().timeout(Duration.ofSeconds(50L));
17
18
19return Mono.zip(firstResp,secResp).map(objects ->{
20    if(firstResp != null)
21    response.addAll(Mapper.convert(objects.getT1()));
22    if(secResp != null);
23    response.addAll(Mapper.convert(objects.getT2()));
24    return response;
25});
26
27}
28
29public  List<Response> convert(FirstApiResponse resp){
30    ////
31    Mapping to Response object 
32    ////
33
34    return response;
35}
36
37public  List<Response> convert(SecondApiResponse resp){
38     ////
39    Mapping to Response object 
40    ////
41
42    return response;
43}
44Mono<Wrapper<FirstApiResponse>> gResp = this.firstWebClient.get().uri(uriBuilder -> uriBuilder
45     .path("/")
46     .queryParam("q", input)
47     .build()).retrieve()
48     .bodyToMono(FirstApiResponse.class).log()
49     .map( response -> new Wrapper().withResponse(response))
50     .timeout(Duration.ofSeconds(50L))
51     .doOnError(throwable -> logger.error("Failed", throwable))
52      .onErrorReturn(new Wrapper().withError( YourDefaultErrorReponse(...));
53
54Mono<SecondApiResponse> iResp = this.secondWebClient.get().uri(uriBuilder -> uriBuilder
55    .path("/search")
56    .queryParam("term", input)
57    .build())
58    .retrieve()      
59    .bodyToMono(SecondApiResponse.class).log()
60    .map( response -> new Wrapper().withResponse(response))
61    .timeout(Duration.ofSeconds(50L))
62    ..doOnError(throwable -> logger.error("Failed", throwable))
63    .onErrorReturn(new Wrapper().withError( YourDefaultErrorReponse(...))
64

1public Mono<List<Response>> getRecords(String input){
2
3List<Response> response = new ArrayList<>();
4
5Mono<FirstApiResponse> gResp = this.firstWebClient.get().uri(uriBuilder -> uriBuilder
6            .path("/")
7            .queryParam("q", input)
8            .build()).retrieve()
9            .bodyToMono(FirstApiResponse.class).log()
10            .timeout(Duration.ofSeconds(50L));
11
12Mono<SecondApiResponse> iResp = this.secondWebClient.get().uri(uriBuilder -> uriBuilder
13        .path("/search")
14        .queryParam("term", input)
15        .build()).retrieve()
16        .bodyToMono(SecondApiResponse.class).log().timeout(Duration.ofSeconds(50L));
17
18
19return Mono.zip(firstResp,secResp).map(objects ->{
20    if(firstResp != null)
21    response.addAll(Mapper.convert(objects.getT1()));
22    if(secResp != null);
23    response.addAll(Mapper.convert(objects.getT2()));
24    return response;
25});
26
27}
28
29public  List<Response> convert(FirstApiResponse resp){
30    ////
31    Mapping to Response object 
32    ////
33
34    return response;
35}
36
37public  List<Response> convert(SecondApiResponse resp){
38     ////
39    Mapping to Response object 
40    ////
41
42    return response;
43}
44Mono<Wrapper<FirstApiResponse>> gResp = this.firstWebClient.get().uri(uriBuilder -> uriBuilder
45     .path("/")
46     .queryParam("q", input)
47     .build()).retrieve()
48     .bodyToMono(FirstApiResponse.class).log()
49     .map( response -> new Wrapper().withResponse(response))
50     .timeout(Duration.ofSeconds(50L))
51     .doOnError(throwable -> logger.error("Failed", throwable))
52      .onErrorReturn(new Wrapper().withError( YourDefaultErrorReponse(...));
53
54Mono<SecondApiResponse> iResp = this.secondWebClient.get().uri(uriBuilder -> uriBuilder
55    .path("/search")
56    .queryParam("term", input)
57    .build())
58    .retrieve()      
59    .bodyToMono(SecondApiResponse.class).log()
60    .map( response -> new Wrapper().withResponse(response))
61    .timeout(Duration.ofSeconds(50L))
62    ..doOnError(throwable -> logger.error("Failed", throwable))
63    .onErrorReturn(new Wrapper().withError( YourDefaultErrorReponse(...))
64public final class Wrapper<T> {
65  private T response ;
66  private Error error;
67      
68  public Wrapper<T> withResponse ( T response ){
69     this.response = response;
70     return this;
71  }
72  public Wrapper<T> withError( Error error) {
73     this.error = error;
74     return this;
75  }
76
77  public Boolean hasError(){
78    return error != null ;
79  }
80      
81  public T getResponse(){
82   return response;
83  }
84}
85

1Required Type: Mono<String>, 
2Provided: Mono<Object>
3no instance(s) of type variable(s) T exist so that Mono<T> conforms to String inference variable R has incompatible bounds: equality constraints
4public Mono<String> moveToDB(String pid, String op, MoveRequest moveRequest) {
5        return Mono.just(pid)
6                .subscribeOn(Schedulers.boundedElastic())
7                .map(id -> persistenceService.withTransaction((s, em) -> {
8                     //some code goes here
9                    if (condition)
10                       return "data sync failed"; //ERROR
11                    return "data synced successfully"; //ERROR
12        }));
13}
14.map(id -> service.withTransaction((s, em) -> {
15    //some code goes here
16    if (true)
17        return "data sync failed";
18    return "data synced successfully";
19}))
20.map(e -> e.toString()); //or whatever
21

1library(shiny)
2
3ui <- fluidPage(
4    textInput("age", "How old are you?"),
5    textOutput("message")
6)
7
8server <- function(input, output, server) {
9    message <- paste0("You are ", input$age) |> reactive({})
10    output$message <- renderText(message())
11}
12
13shinyApp(ui, server)
14Listening on http://127.0.0.1:4346
15Warning: Error in : `env` must be an environment
16  56: <Anonymous>
17Error : `env` must be an environment
18server <- function(input, output, server) {
19        message <- reactive({paste0("You are ", input$age, " years old")})
20        output$message <- renderText(message())
21}
22library(shiny)
23
24ui <- fluidPage(
25  textInput("age", "How old are you?"),
26  textOutput("message")
27)
28
29server <- function(input, output, server) {
30  message <- paste0("You are ", input$age) |> reactive()
31  output$message <- renderText(message())
32}
33
34shinyApp(ui, server)
35