juplo.de Git - demos/kafka/chat/blob - src/main/java/de/juplo/kafka/chat/backend/api/ChatBackendController.java

   1 package de.juplo.kafka.chat.backend.api;
   2
   3 import de.juplo.kafka.chat.backend.ChatBackendProperties;
   4 import de.juplo.kafka.chat.backend.domain.ChatHomeService;
   5 import de.juplo.kafka.chat.backend.domain.ChatRoomData;
   6 import de.juplo.kafka.chat.backend.implementation.StorageStrategy;
   7 import org.springframework.http.codec.ServerSentEvent;
   8 import org.springframework.web.bind.annotation.*;
   9 import reactor.core.publisher.Flux;
  10 import reactor.core.publisher.Mono;
  11
  12 import java.util.UUID;
  13 import java.util.logging.Level;
  14
  15
  16 @RestController
  17 public class ChatBackendController
  18 {
  19   private final ChatHomeService chatHomeService;
  20   private final StorageStrategy storageStrategy;
  21   private final String loggingCategory = ChatBackendController.class.getSimpleName();
  22   private final Level loggingLevel;
  23   private final boolean showOperatorLine;
  24
  25
  26   public ChatBackendController(
  27       ChatHomeService chatHomeService,
  28       StorageStrategy storageStrategy,
  29       ChatBackendProperties properties)
  30   {
  31     this.chatHomeService = chatHomeService;
  32     this.storageStrategy = storageStrategy;
  33     this.loggingLevel = properties.getProjectreactor().getLoggingLevel();
  34     this.showOperatorLine = properties.getProjectreactor().isShowOperatorLine();
  35   }
  36
  37
  38   @PostMapping("create")
  39   public Mono<ChatRoomInfoTo> create(@RequestBody String name)
  40   {
  41     UUID chatRoomId = UUID.randomUUID();
  42     return chatHomeService
  43         .createChatRoom(chatRoomId, name)
  44         .map(ChatRoomInfoTo::from);
  45   }
  46
  47   @GetMapping("list")
  48   public Flux<ChatRoomInfoTo> list()
  49   {
  50     return chatHomeService
  51         .getChatRoomInfo()
  52         .map(chatroomInfo -> ChatRoomInfoTo.from(chatroomInfo));
  53   }
  54
  55   @GetMapping("{chatRoomId}/list")
  56   public Flux<MessageTo> list(@PathVariable UUID chatRoomId)
  57   {
  58     return chatHomeService
  59         .getChatRoomData(chatRoomId)
  60         .flatMapMany(chatRoomData -> chatRoomData
  61             .getMessages()
  62             .map(MessageTo::from));
  63   }
  64
  65   @GetMapping("{chatRoomId}")
  66   public Mono<ChatRoomInfoTo> get(@PathVariable UUID chatRoomId)
  67   {
  68     return chatHomeService
  69         .getChatRoomInfo(chatRoomId)
  70         .map(chatRoomInfo -> ChatRoomInfoTo.from(chatRoomInfo));
  71   }
  72
  73   @PutMapping("{chatRoomId}/{username}/{messageId}")
  74   public Mono<MessageTo> put(
  75       @PathVariable UUID chatRoomId,
  76       @PathVariable String username,
  77       @PathVariable Long messageId,
  78       @RequestBody String text)
  79   {
  80     return
  81         chatHomeService
  82             .getChatRoomData(chatRoomId)
  83             .flatMap(chatRoomData -> put(chatRoomData, username, messageId, text));
  84   }
  85
  86   private Mono<MessageTo> put(
  87       ChatRoomData chatRoomData,
  88       String username,
  89       Long messageId,
  90       String text)
  91   {
  92     return
  93         chatRoomData
  94             .addMessage(
  95                 messageId,
  96                 username,
  97                 text)
  98             .map(message -> MessageTo.from(message));
  99   }
 100
 101   @GetMapping("{chatRoomId}/{username}/{messageId}")
 102   public Mono<MessageTo> get(
 103       @PathVariable UUID chatRoomId,
 104       @PathVariable String username,
 105       @PathVariable Long messageId)
 106   {
 107     return
 108         chatHomeService
 109             .getChatRoomData(chatRoomId)
 110             .flatMap(chatRoomData -> get(chatRoomData, username, messageId));
 111   }
 112
 113   private Mono<MessageTo> get(
 114       ChatRoomData chatRoomData,
 115       String username,
 116       Long messageId)
 117   {
 118     return
 119         chatRoomData
 120             .getMessage(username, messageId)
 121             .map(message -> MessageTo.from(message));
 122   }
 123
 124   @GetMapping(path = "{chatRoomId}/listen")
 125   public Flux<ServerSentEvent<MessageTo>> listen(@PathVariable UUID chatRoomId)
 126   {
 127     return chatHomeService
 128         .getChatRoomData(chatRoomId)
 129         .flatMapMany(chatRoomData -> listen(chatRoomData));
 130   }
 131
 132   private Flux<ServerSentEvent<MessageTo>> listen(ChatRoomData chatRoomData)
 133   {
 134     return chatRoomData
 135         .listen()
 136         .log(
 137             loggingCategory,
 138             loggingLevel,
 139             showOperatorLine)
 140         .map(message -> MessageTo.from(message))
 141         .map(messageTo ->
 142             ServerSentEvent
 143                 .builder(messageTo)
 144                 .id(messageTo.getSerial().toString())
 145                 .event("message")
 146                 .build());
 147   }
 148
 149   @GetMapping("/shards")
 150   public Mono<String[]> getShardOwners()
 151   {
 152     return chatHomeService.getShardOwners();
 153   }
 154
 155   @PostMapping("/store")
 156   public void store()
 157   {
 158     storageStrategy
 159         .write(chatHomeService)
 160         .subscribe();
 161   }
 162 }