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